Patch
Expo's OTA workflow, for native Swift.
EAS Update is brilliant — for React Native. It can't touch a native Swift app. Patch is the native-iOS equivalent: ship over-the-air code updates with no App Store review, roll back the whole fleet instantly, and never leave Swift for JavaScript.
EAS Update updates JavaScript. Patch updates Swift.
Same over-the-air idea — applied to the native stack Expo was never meant to cover.
Expo's EAS Update (and the older Expo Updates) ship a new JavaScript bundle to a React Native app so you can fix bugs and tweak features without a store release. It's a great workflow — if your app is React Native. A genuinely native iOS app written in Swift and SwiftUI has no JS bundle, so EAS Update has nothing to deliver, and every fix waits on App Store review.
Patch is that missing piece for native teams. You write ordinary Swift; the Patch CLI compiles the parts that changed to WebAssembly and ships them as a patch, and the on-device SDK runs that WebAssembly in the WasmKit runtime. Covered code — logic, async/await, and opt-in SwiftUI views — updates without App Store review, and any release rolls back across your fleet instantly. The imperative update API even mirrors Expo's familiar check → fetch → reload flow, so it feels like home — minus the JavaScript bridge and the web views.
Expo / EAS Update vs. Patch
| Expo / EAS Update | Patch | |
|---|---|---|
| Target stack | React Native (JavaScript / TypeScript) | Native Swift & SwiftUI |
| What ships over the air | JavaScript bundle & assets | Your Swift, compiled to WebAssembly |
| On-device runtime | JavaScript engine (Hermes / JSC) | WasmKit (no JS bridge, no web view) |
| Works for native Swift apps | No | Yes — that's the point |
| No App Store review for covered changes | Yes | Yes |
| Instant fleet-wide rollback | Yes | Yes |
| Staged rollouts, channels & targeting | Yes | Yes |
| Update API style | check / fetch / reload | check / fetch / reload (familiar by design) |
Which one is right for you?
It comes down to one question: what is your app actually built in?
Expo / EAS Update
Cross-platform JavaScript app? Stay with Expo — EAS Update is purpose-built for it, with a mature ecosystem. Patch isn't for you; it ships native Swift, not JavaScript bundles.
Patch
Native iOS in Swift and SwiftUI? Patch is the only OTA tool that updates real native code over the air — no rewrite into React Native, no JS bridge, no web views, and the same instant-fix workflow you've envied from the Expo world.
Allowed by Apple. Imperceptible to users.
It's explicitly allowed by Apple's own rules. Apple's Developer Program License Agreement (section 3.3.2) expressly permits an app to download and run interpreted code, as long as it doesn't change the app's primary purpose, create a storefront for other code, or bypass the OS sandbox and code signing. Patch meets all three — your signed App Store binary never changes, only the interpreted WebAssembly layer updates. This is the exact same provision Expo / EAS Update and CodePush have relied on for nearly a decade, across tens of thousands of live App Store apps.
The performance overhead is negligible. Patched code runs in WasmKit at near-native speed; for the kind of code Patch ships — business logic, validation, pricing, view construction — the cost is measured in microseconds, far below anything a person could perceive. There's zero impact on launch (the SDK activates the cached module instantly, even offline), and anything genuinely performance-critical stays native automatically, so your hot paths are always compiled machine code.
Expo vs. Patch, answered.
No. Expo and EAS Update deliver over-the-air updates to React Native apps by replacing the JavaScript bundle. A native Swift/SwiftUI app has no JavaScript bundle, so there's nothing for EAS Update to update. Patch is the equivalent for native iOS: it compiles your changed Swift to WebAssembly and ships it over the air, giving native teams the same instant-update workflow without React Native.
Yes — that's exactly the idea. Patch brings the EAS Update / Expo Updates model (push interpreted code over the air, skip App Store review for covered changes, roll back instantly) to native Swift. The imperative update API even mirrors Expo's check / fetch / reload flow, so the developer experience feels familiar — but you stay in native Swift with no JS bridge and no web views.
No — the opposite. Patch exists precisely so you don't have to adopt React Native to get over-the-air updates. You keep writing ordinary Swift and SwiftUI. Run patchcli init once — it registers your app, adds the Swift package, and inserts the startup code for you — then ship updates with the CLI. If you build cross-platform in React Native, Expo / EAS Update is the right tool; if you build native iOS, Patch is.
Yes — it's explicitly allowed by Apple's own rules. Apple's Developer Program License Agreement §3.3.2 expressly permits an app to download and run interpreted code, as long as it doesn't change the app's primary purpose, create a storefront for other code, or bypass the OS sandbox and code signing. Patch meets all three: your signed binary never changes, only the interpreted WebAssembly layer updates. It's the exact same provision Expo / EAS Update and CodePush have relied on for nearly a decade across tens of thousands of App Store apps.
No — the overhead is negligible. Patched code runs in the WasmKit runtime at near-native speed, and for the logic Patch ships the per-call cost is on the order of microseconds, far below anything a user could perceive. There's no launch penalty, and anything performance-critical stays native automatically, so your hot paths are always compiled machine code.
Bring OTA updates to your Swift app today.
Free to start. No React Native. No App Store review.