Patch
The Shorebird alternative for native Swift iOS apps.
Shorebird brought code push to Flutter. But it updates Dart — it can't touch native Swift. Patch is the over-the-air update tool for genuinely native iOS: ship covered Swift and SwiftUI changes with no App Store review, roll the whole fleet back in one click, and never adopt Flutter or Dart.
Shorebird is for Flutter. Patch is for native Swift.
The same idea — push interpreted code over the air, skip the review queue — applied to the stack Shorebird was never built for.
Shorebird updates the Dart code of a Flutter app, running your patched Dart on a modified Flutter engine. If your app is genuinely native — written in Swift and SwiftUI — there is no Dart layer for Shorebird to update, so instant OTA fixes simply weren't an option. You waited on App Store review for every one-line change.
Patch closes that gap without asking you to leave native iOS. You keep writing ordinary Swift. The Patch CLI compiles the parts of your code that changed to WebAssembly and ships them as a tiny patch; the on-device SDK runs that WebAssembly in the WasmKit runtime. Covered Swift logic, async/await, and SwiftUI views update without App Store review, and any release rolls back across your entire fleet instantly — the workflow Shorebird popularized for Flutter, now native to Swift, with no Flutter, no Dart, and no web view.
Shorebird vs. Patch
| Shorebird | Patch | |
|---|---|---|
| Target stack | Flutter (Dart) | Native Swift & SwiftUI |
| What ships over the air | New Dart code | Your Swift, compiled to WebAssembly |
| On-device runtime | Modified Flutter engine | WasmKit (no Flutter, no web view) |
| Updates native Swift / SwiftUI | No — Dart only | Yes — that's the point |
| Cross-platform framework required | Yes (Flutter) | No — stay native |
| No App Store review for covered changes | Yes | Yes |
| Instant fleet-wide rollback | Yes | Yes |
| Staged rollouts & targeting | Yes | Yes |
Which one is right for you?
We'll be honest about it — pick by the stack you actually ship.
Shorebird
Your app runs on the Flutter engine and your code is Dart, so a Flutter-native code-push tool is the right fit. Shorebird is built by veterans of the Flutter team and integrates cleanly with a Flutter release workflow. Patch isn't for you — it doesn't ship Dart.
Patch
You write Swift and SwiftUI, not Dart. Patch is the only OTA tool that updates genuinely native iOS code — logic, async/await, and SwiftUI views (out of the box, no PatchView) — over the air, with instant rollback and no review queue.
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 same provision Shorebird, Expo / EAS Update, and CodePush rely on to push interpreted code over the air, applied to native Swift.
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.
Shorebird vs. Patch, answered.
No. Shorebird is code push for Flutter — it ships new Dart code to a Flutter app through a modified Flutter engine. It updates the Dart layer only and does not update native Swift, SwiftUI, Kotlin, or Objective-C. If your iOS app is built in native Swift rather than Flutter, Shorebird has no Dart layer to update. Patch is built for exactly that case: it compiles your changed native Swift to WebAssembly and ships it over the air, run on-device in WasmKit.
Yes — Patch. Shorebird is the over-the-air update tool for Flutter; Patch is the over-the-air update tool for native Swift. You keep writing ordinary Swift and SwiftUI, and Patch compiles the parts you changed to WebAssembly and runs them on-device in WasmKit, so you can ship covered code updates with no App Store review and roll the whole fleet back instantly — the same model Shorebird gives Flutter teams, made for native iOS.
They solve the same problem for different stacks. Shorebird updates Dart in Flutter apps via a modified Flutter engine. Patch updates native Swift and SwiftUI by compiling the changed code to WebAssembly and running it in the WasmKit runtime on-device — no Flutter, no Dart, no cross-platform framework, no web view. Both skip the App Store review queue for covered changes and roll back instantly; the difference is the language and runtime your app actually uses.
No. Patch is the opposite choice from a cross-platform framework. You build a genuinely native iOS app in Swift and SwiftUI, and Patch makes the covered parts of that Swift updatable over the air. There's no Flutter, no Dart, and no rewrite — you install the CLI, run patchcli init once, and ship patches from your existing native codebase.
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 satisfies all three: your signed binary never changes, only the interpreted WebAssembly layer updates. It's the same provision Shorebird, Expo / EAS Update, and CodePush rely on to push interpreted code, applied to native Swift.
Ship your first native Swift patch today.
Free to start. No App Store review. Instant rollback. No Flutter.