Lovable · Widgets · Live Activities · Face ID · Wallet
Every native feature your Lovable app can ship
A Lovable app is a web app — but wrapped by AppNative it can carry the same native surfaces a Swift app does: home-screen widgets, Live Activities in the Dynamic Island, Face ID unlock, Wallet passes, Siri shortcuts, quick actions, camera and photo access, HealthKit, offline caching, deep links and universal links. Each one is generated as native code and compiled into your binary.
What native features can a wrapped Lovable app actually use?
With AppNative, a Lovable app ships WidgetKit home-screen and Lock Screen widgets, Live Activities with Dynamic Island, rich push notifications, StoreKit in-app purchases, Face ID and Touch ID unlock, Apple Wallet passes, Siri and App Shortcuts, home-screen quick actions, camera, microphone, photo library, location, HealthKit, offline caching, custom URL schemes, universal links, haptics, screen sharing and native audio — all as compiled native extensions, with your React code untouched.
- Widgets
- WidgetKit small/medium/large/Lock Screen, AI-designed, per-user data
- Live Activities
- Dynamic Island + Lock Screen, updated over push from your backend
- Biometrics
- Face ID / Touch ID app lock and re-auth on foreground
- Wallet
- Signed Apple Wallet + Google Wallet passes with live updates
- Voice & shortcuts
- Siri App Shortcuts, Spotlight, long-press quick actions
- Device APIs
- Camera, photos, mic, location, HealthKit, haptics, offline cache
How to turn a Lovable app into a native mobile app, step by step
Six steps, one codebase, no native development. Each step happens inside AppNative except the first.
- 1
Wrap the Lovable repo
Connect the GitHub repo Lovable syncs to. AppNative detects your framework, routes and theme, and produces a signed native iOS and Android shell around your live app.
- 2
Toggle the capabilities you want
Each feature is a switch: push, widgets, Live Activities, Face ID, Wallet, Siri, camera, location, offline, universal links. AppNative adds the entitlements, permission strings and native targets automatically.
- 3
Design the visual surfaces in AI studios
Widget Studio, Live Activity Studio, the paywall designer and the rich-push designer each write real SwiftUI or Kotlin from a plain-English description and show a live preview.
- 4
Connect them to your data
Point widgets and Live Activities at a JSON feed from Supabase, your Lovable backend or any REST API — AppNative can generate that endpoint's code — and drive updates through its API.
- 5
Build and ship
Hosted CI compiles every extension, signs it with your certificates and uploads to TestFlight and Google Play. Your web app keeps deploying instantly as before.
Native capabilities your Lovable app gains
These are real native implementations compiled into the binary — not browser fallbacks — and they're what moves an app past Apple's "minimum functionality" bar.
- WidgetKit home-screen and Lock Screen widgets with per-user data
- Live Activities and Dynamic Island driven by push from your backend
- Rich push with images, action buttons, custom sounds and badge counts
- StoreKit 2 in-app purchases with native AI-designed paywalls
- Face ID / Touch ID app lock and biometric re-authentication
- Apple Wallet and Google Wallet passes with live field updates
- Siri App Shortcuts, Spotlight indexing and home-screen quick actions
- Camera, photo library, microphone, location, HealthKit and haptics bridges
- Offline caching, custom URL schemes, universal links and app-clip-style deep links
- iMessage extension, native screen sharing and native audio session control
Lovable to mobile: the alternatives, compared
Why most wrappers can't offer these
Widgets, Live Activities and rich notification layouts live in separate app extensions inside the binary, each needing its own target, App Group and provisioning profile. Wrappers that only ship a web view can't produce them. AppNative generates and signs those extensions per app, which is what turns a wrapped Lovable app into a genuinely native product.
AppNative vs Median.co and Despia for Lovable apps
Median and Despia give you a solid web view with basic native plugins. AppNative adds the compiled extensions — WidgetKit, Live Activities, notification content and service extensions, iMessage, broadcast upload — plus Apple-side automation for bundle IDs, certificates, App Store Connect records and in-app purchase products.
Native features vs rewriting in React Native or Flutter
A rewrite gets you native APIs at the cost of a second codebase and months of work. Wrapping keeps one Lovable codebase and still ships the native surfaces users notice: a widget on the home screen, a Live Activity in the Dynamic Island, Face ID at launch.
Lovable to mobile app: every question, answered
The exact questions people ask before shipping a Lovable project to the App Store and Google Play.
Can a Lovable app have a home-screen widget?
Yes. AppNative compiles a WidgetKit extension into the build; you describe the widget in Widget Studio and point it at a JSON feed, optionally scoped to the signed-in user.
Can a Lovable app use the Dynamic Island?
Yes, through Live Activities. AppNative generates the ActivityKit widget and gives you an API to start, update and end activities from your backend — deliveries, matches, timers, order status.
Can I lock my Lovable app behind Face ID?
Yes. Enable biometric app lock and the native shell requires Face ID or Touch ID on launch and optionally when returning to the foreground.
Can I issue Apple Wallet passes from a Lovable app?
Yes. AppNative generates the signed .pkpass, hosts the Wallet web service for updates, and gives you an API to change fields on a pass already in a user's Wallet.
Do these features work on Android?
The equivalents do: home-screen widgets, rich notifications with expanded layouts and buttons, biometric unlock, Google Wallet passes, deep links and offline caching.
Web app to mobile app: key terms defined
- Native app wrapper
- A native app wrapper is a compiled iOS or Android application that renders your existing web app inside a native web view (WKWebView on iOS, WebView on Android) while exposing real device capabilities — push notifications, biometrics, camera, in-app purchases — to that web code through a JavaScript bridge.
- Hybrid app
- A hybrid app ships web technologies (HTML, CSS, JavaScript) inside a native binary that can be distributed through the App Store and Google Play. It differs from a progressive web app, which is installed from the browser and cannot be listed in either store.
- App Store guideline 4.2 (minimum functionality)
- Apple's rule that an app must do more than repackage a website. Apps that add native capability — push notifications, biometric login, camera use, offline support, widgets, in-app purchases — satisfy it; a bare website in a shell does not.
- Bundle ID / package name
- The permanent reverse-domain identifier for your app (for example com.yourcompany.yourapp). It's registered once with Apple and Google and can never be changed for a published app, so it must be decided before your first submission.
- Code signing and provisioning profile
- Apple requires every binary to be signed with a distribution certificate and matched to a provisioning profile tied to your bundle ID and team. Android requires an upload keystore. Without them a build cannot be installed or submitted.
- TestFlight
- Apple's beta distribution service. Uploading a signed build to TestFlight lets up to 100 internal testers install the app immediately, before public App Store review — the fastest way to see your wrapped app on a real device.
- Over-the-air update
- Because a wrapper renders your live web app, deploying your web app updates the mobile experience instantly with no store review. A new native build is only required when something inside the binary changes: icon, splash screen, bundle ID or a native capability.
- StoreKit and Google Play Billing
- The in-app purchase systems Apple and Google require for selling digital goods inside an app. Stripe stays valid on the web, so most apps run both and grant the same entitlement from either payment source.
Lovable to mobile app: frequently asked questions
Do I have to write any Swift or Kotlin?
No. Every native surface is generated for you — SwiftUI widgets and Live Activities, Kotlin notification layouts, StoreKit paywalls — and validated before the build runs.
Does enabling more capabilities slow my app down?
No. Extensions only run when the system invokes them (a widget refresh, an incoming notification), and your web app loads exactly as it does today.
Will my Lovable workflow change?
No. Keep prompting in Lovable and deploying to the web; rebuild the native app only when you change native features, icons or versions.
Which features help most with App Store approval?
Push notifications, widgets, Live Activities, Face ID and offline mode are the clearest signals of native functionality under guideline 4.2.
Can I add features later?
Yes. Toggle a capability, rebuild, and the new extension ships in the next TestFlight build.
Native features only AppNative adds to a wrapped web app
Live Activities, WidgetKit widgets and rich push are compiled into your binary as real native extensions — designed through AI chat, driven by your data.
Ship from your AI app builder
Go deeper on a specific surface, or read the full Lovable → native app guide to start from the beginning.
Deep dives by builder and feature
Step-by-step guides for the specific thing you're trying to ship — push, in-app purchases, widgets, store submission — for Lovable and Base44 apps, plus how AppNative compares to Median.co and Despia.
Ship your Lovable app to the App Store and Google Play
Connect your repo, toggle the native features you need, press Build. Your first TestFlight build can be in testers' hands today — and your Lovable workflow doesn't change at all.