Base44 · Widgets · Live Activities · Face ID · Wallet · IAP
Every native feature your Base44 app can ship
Your Base44 entities and backend functions already hold the data. AppNative turns that data into native surfaces: a home-screen widget showing today's numbers, a Live Activity in the Dynamic Island, StoreKit subscriptions, Face ID at launch, Wallet passes that update themselves, Siri shortcuts, camera and offline access — compiled into your binary, with no Swift or Kotlin.
What native features can a wrapped Base44 app use?
With AppNative, a Base44 app ships WidgetKit home-screen and Lock Screen widgets, Live Activities with Dynamic Island, rich push notifications, StoreKit 2 in-app purchases with native paywalls, Face ID and Touch ID app lock, Apple and Google Wallet passes, Siri App Shortcuts, quick actions, camera, microphone, photo library, location, HealthKit, offline caching, custom URL schemes and universal links — each generated as native code and fed by your Base44 backend functions.
- Widgets
- WidgetKit in every size, fed by a Base44 function returning JSON
- Live Activities
- Dynamic Island + Lock Screen, updated via API from your functions
- Payments
- StoreKit 2 and Google Play Billing with AI-designed paywalls
- Security
- Face ID / Touch ID app lock and foreground re-auth
- Wallet
- Signed passes with a hosted update web service
- Device APIs
- Camera, photos, mic, location, HealthKit, haptics, offline cache
How to turn a Base44 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 your Base44 app
Connect the repo behind your Base44 app and set the identity, icon and splash. AppNative produces a signed native iOS and Android shell around the live app.
- 2
Switch on the capabilities you need
Push, widgets, Live Activities, IAP, Face ID, Wallet, Siri, camera, location, offline, universal links — each toggle adds the entitlements, permission strings and native targets for you.
- 3
Design the surfaces with AI studios
Widget Studio, Live Activity Studio, the rich-push designer and the paywall designer write real SwiftUI and Kotlin from a description, with live previews before you build.
- 4
Feed them from Base44 functions
AppNative can generate the exact backend function that returns the JSON a widget or Live Activity expects — including per-user scoping using the signed-in Base44 user.
- 5
Build and ship
Hosted CI compiles and signs every extension and uploads to TestFlight and Google Play. Your Base44 deploys continue to reach users instantly.
Native capabilities your Base44 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 fed by your Base44 functions
- Per-user widget data scoped to the signed-in Base44 user
- Live Activities and Dynamic Island updated over push from your backend
- Rich push with images, action buttons, custom sounds and badge counts
- StoreKit 2 subscriptions with native paywalls, route gating and feature flags
- Face ID / Touch ID app lock and biometric re-authentication
- Apple Wallet and Google Wallet passes with live field updates
- Siri App Shortcuts, Spotlight and long-press home-screen quick actions
- Camera, photo library, microphone, location, HealthKit and haptics bridges
- Offline caching, custom URL schemes, universal links and iMessage extension
Base44 to mobile: the alternatives, compared
Why these need compiled extensions
Widgets, Live Activities and rich notification layouts run in separate extensions inside the binary, each with its own target, App Group and provisioning profile. A wrapper that only loads a web view cannot ship them. AppNative generates and signs those extensions per app, which is what makes a wrapped Base44 app feel native.
AppNative vs Median.co and Despia for Base44 apps
Median and Despia deliver a reliable web view with basic plugins. AppNative adds compiled WidgetKit, ActivityKit, notification service and content extensions, StoreKit product automation, Wallet signing, and code generation for the Base44 functions that feed them.
Native surfaces vs a full rewrite
Rewriting in React Native duplicates your Base44 entities, auth and UI. Wrapping keeps one app and still puts a widget on the home screen, a Live Activity in the Dynamic Island and Face ID at launch.
Base44 to mobile app: every question, answered
The exact questions people ask before shipping a Base44 project to the App Store and Google Play.
Can a Base44 app have a home-screen widget?
Yes. Describe it in Widget Studio and expose a small JSON endpoint from a Base44 backend function — AppNative can write that function — then build. The widget can be scoped per user.
Can a Base44 app use the Dynamic Island?
Yes, via Live Activities. AppNative generates the ActivityKit widget and gives you an API to start, update and end activities from your functions or workflows.
Can I sell subscriptions in a Base44 app on iOS?
Yes, through StoreKit 2. AppNative creates the products in App Store Connect, shows a native paywall, and exposes the entitlement to your Base44 code so premium pages unlock.
Can I require Face ID to open the app?
Yes. Biometric app lock is a toggle, with optional re-authentication when the app returns to the foreground.
Do the Android equivalents exist?
Yes: home-screen widgets, rich notifications with expanded layouts and buttons, Play Billing, 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.
Base44 to mobile app: frequently asked questions
Do I write any native code?
No. SwiftUI widgets, Live Activities, Kotlin notification layouts and StoreKit paywalls are all generated and validated for you before the build.
Where does widget and Live Activity data come from?
From your own Base44 backend functions returning JSON. Nothing is copied out of your app — the native surfaces read your live data.
Does my Base44 workflow change?
No. Keep building and deploying in Base44; rebuild the native app only when you change native capabilities, icons or versions.
Which features matter most for App Store approval?
Push notifications, widgets, Live Activities, Face ID and offline mode most clearly demonstrate native functionality under guideline 4.2.
Can I add capabilities after launch?
Yes. Toggle the capability, rebuild, and the extension ships in your next TestFlight and Play update.
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 single surface, or read the full Base44 → 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 Base44 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 Base44 workflow doesn't change at all.