---
title: "Best Native App Makers in 2026: 13 Tools Ranked | Superapp"
description: "Most app makers call their output native. We checked what each of 13 tools actually ships: real Swift, React Native, or a WebView wrapper."
image: https://superapp.dev/lovable-uploads/bc4914af-9cbc-4b4c-a764-13dde52ee116.webp
canonical_url: https://superapp.dev/blog/best-native-app-makers-2026
md_url: https://superapp.dev/blog/best-native-app-makers-2026.md
---
Last updated: September 2026

## Best Native App Makers in 2026: The Short Answer

Superapp is the only tool on this page that generates native Swift source you can read, export and own, which is why it ranks first here, and as a disclosure it is our product, so weigh this accordingly. Every other tool in this comparison produces something else: Flutter, React Native, a vendor-controlled binary, or a browser frame pointed at your website. All of them are marketed with the same word.

"Native" is the least reliable word in the app-building market. Almost every tool on this page uses it, and they mean at least four different things by it. Some generate Swift you can open in Xcode. Some render your interface with real platform views driven by JavaScript. Some compile a store binary you can never look inside. Some wrap your website in a browser frame and call the result native anyway.

> Quick answer: Superapp generates native Swift source you can export and own, from $25 a month, Apple platforms only. If you need iOS and Android from one project and you still want the code, FlutterFlow at $39 a month exports Flutter and Draftbit at $12 a month exports React Native. Expo with React Native is free and open source if you can write TypeScript. If you cannot export anything, you are in Tier 3: Bubble at $59 a month annually, Adalo at $36, and Thunkable at $37 all ship a real store binary but keep the source, and Thunkable's own FAQ confirms your live app stops working if your subscription lapses. Glide cannot publish to the App Store at all, in its own words, because it builds progressive web apps. Add $99 a year for the Apple Developer Program to every option.

Here is the whole field, sorted by what the tool actually produces rather than by what it claims.

| Rank | Tool | What it actually produces | Export the source? | Entry price |
| --- | --- | --- | --- | --- |
| 1 | Superapp | Native Swift source, Apple platforms only | Yes, full export | Free tier, Pro $25/mo |
| 2 | Expo + React Native | Native UI views driven by JavaScript, open source | It is your source | Free, EAS from $0 |
| 3 | FlutterFlow | Flutter/Dart compiled to a store binary | Yes, on Basic and above | Free tier, Basic $39/mo |
| 4 | Draftbit | React Native + Expo codebase | Yes, on Standard and above | Free tier, Standard $12/mo |
| 5 | Newly (formerly Natively) | React Native + Expo SDK 54, TypeScript | Yes, ZIP and GitHub | $25/mo, no free tier |
| 6 | Xcode + SwiftUI | Native Swift, Apple's own toolchain | It is your source | Free, requires a Mac |
| 7 | Bubble | React Native, in Bubble's own words | No | Free tier, Starter $59/mo annual |
| 8 | Adalo | Compiled IPA/AAB, React Native UI layer | No | Free tier, Starter $36/mo annual |
| 9 | Thunkable | Undocumented, claims native | No documented export | Free tier, Builder $37/mo annual |
| 10 | Capacitor | Web app in a native runtime container | It is your web source | Free, MIT licensed |
| 11 | Median.co | WebView wrapper of an existing website | No | Self-serve from $0 |
| 12 | BuildNatively | WebView wrapper of an existing website | No | Free tier, Essential $12/mo yearly |
| 13 | Glide | Progressive web app, cannot reach the App Store | No | Free tier, Basic $25/mo |

## Positioning at a Glance

One line per tool, so you can find yourself without reading the whole page.

| Tool | What it is actually for |
| --- | --- |
| Superapp | Getting native Swift for an Apple-only app without owning a Mac or learning Swift |
| Expo + React Native | Developers who want total control and will write TypeScript to get it |
| FlutterFlow | Visual builders who need iOS and Android from one project and want the Dart code |
| Draftbit | The cheapest route to a real React Native codebase you can export |
| Newly | Prompting an MVP into existence and walking away with the GitHub repo |
| Xcode + SwiftUI | Learning to build Apple apps properly, with a skill that outlasts subscriptions |
| Bubble | Teams already running a Bubble web app who now want it on phones |
| Adalo | Drag-and-drop app building where publishing matters more than owning code |
| Thunkable | Beginners who want blocks-based building and accept subscription dependency |
| Capacitor | Web teams who want their existing web app in a store-ready native container |
| Median.co | Businesses turning an established website into a store app, with services attached |
| BuildNatively | The cheapest WebView wrapper for a website you already run |
| Glide | Internal business tools over a spreadsheet, where no app store is needed |

## How We Judged These Tools

We ignored marketing copy entirely. Every claim in this article comes from one of three places: a vendor's own documentation, Apple's published guidelines and transparency reports, or a dated review with a visible star rating on G2, Capterra, Trustpilot or Product Hunt.

Where a vendor's marketing and its own developer documentation disagree, we quote both and link both, and we say which one we find more credible and why. That happens twice on this page and it is the most useful thing here.

Where we could not verify something, we say so rather than estimating. That includes FlutterFlow's annual dollar figures, Bubble's month-to-month rates, Newly's tiers above the entry price, Thunkable's underlying framework, and Superapp's own review score, because it has no third-party review listing at all. A missing number is a finding, not a gap to paper over.

We also report sample sizes with every rating. A 4.8 from four reviews and a 4.4 from 334 are not the same claim, and several comparison articles in this category present them as though they are.

## What Does Native Actually Mean?

A native app is written in the language the platform itself uses, compiled into a binary that runs directly on the device, and built against the platform's own interface frameworks. On iOS that means Swift or Objective-C with SwiftUI or UIKit. On Android it means Kotlin or Java.

Apple does not publish a one-line definition of the term, but it is clear about what you build an Apple app with. Apple's Technology Overviews tell developers that "at the start of every new project, you need to choose an app-builder technology to use for your initial code," and that ["SwiftUI is the best option when you're learning to program for Apple platforms, or when you want to create a new app,"](https://developer.apple.com/documentation/TechnologyOverviews/app-design-and-ui.md) with UIKit and AppKit offering "a more traditional, object-oriented approach." On the compilation question, Apple says [Swift code "is transformed into optimized machine code"](https://developer.apple.com/swift/) using LLVM.

The interesting part is that the most honest definition in this market comes from React Native, the framework most often accused of not being native. React Native does not claim your JavaScript becomes Swift. It claims something more precise: ["Written in JavaScript, rendered with native code. React primitives render to native platform UI, meaning your app uses the same native platform APIs other apps do."](https://reactnative.dev/)

Its documentation spells out the mechanism: ["In Android development, you write views in Kotlin or Java; in iOS development, you use Swift or Objective-C. With React Native, you can invoke these views with JavaScript using React components. At runtime, React Native creates the corresponding Android and iOS views for those components."](https://reactnative.dev/docs/intro-react-native-components)

Read those two sentences carefully, because they are the fault line this whole page sits on. "Rendered with native code" is not the same claim as "compiled to native code." React Native is scrupulous about the difference. Several tools built on top of React Native are not, and describe their output as compiling to native code, which is a looser claim than the framework they are using makes for itself.

This matters practically, not just semantically. A React Native app's interface is made of real platform views, so it looks and feels right. But your application logic runs in JavaScript, which is why performance complaints about React-Native-based builders cluster around heavy screens and long lists rather than around buttons looking wrong. One Adalo customer put the consequence in a single question, quoted in full later on this page: why is a progressive web app on the same device about ten times faster than the native Android build?

## What Is Native Mobile App Development?

Native mobile app development means building an app specifically for one platform, using that platform's own language, tools and interface frameworks, and shipping a compiled binary through that platform's store.

In practice on iOS that is Swift written in Xcode against SwiftUI or UIKit, compiled by LLVM into machine code, packaged as an IPA and submitted through App Store Connect. On Android it is Kotlin in Android Studio against Jetpack Compose or the View system, packaged as an AAB and submitted through Google Play Console.

The defining characteristic is not speed or polish, although you tend to get both. It is that there is no intermediate layer. Your code calls the operating system directly, so anything the platform can do, your app can do, on the day the platform ships it. When Apple introduces a new API at WWDC, a native app can adopt it immediately. Everything else on this page waits for a framework, a runtime or a vendor to expose it first.

That is also the honest cost. One platform means one codebase per platform, which is why cross-platform frameworks exist and why most of the tools on this page are built on them.

## What Are Some Examples of Native Apps?

Apple's own apps are the cleanest examples: Messages, Maps, Photos, Notes and Safari are all built with Apple's frameworks against Apple's APIs. Anything shipped by Apple on an iPhone is native by definition.

Beyond Apple, the honest answer is that you usually cannot tell by looking, which is the point. Well-built React Native and Flutter apps are indistinguishable from native ones to a user, because React Native renders real platform views and Flutter draws a faithful interface of its own. React Native's documentation names Discord, Shopify and Instagram among the apps built with it, and Newly cites the same three as evidence for its own output.

So "is this app native" is rarely a question you can answer from the outside. It is a question about how it was built, what it can reach, and who can maintain it, which is exactly why this article judges tools by their documentation rather than by their output's appearance.

The reverse is easier to spot. A WebView wrapper usually gives itself away: pull-to-refresh behaves like a browser, text selection feels wrong, the app shows a loading spinner where a native screen would already be drawn, and it does very little without a connection.

## Why Two Products Named Natively Land in Different Tiers

The clearest evidence that the word has stopped doing useful work is that two live products share the name and sit three tiers apart.

natively.dev now redirects to newly.app. The company describes itself as ["Newly, formerly Natively, a Stockholm-based team turning ideas into compliant, production-ready iOS and Android apps."](https://newly.app/about) Its documented stack is [React Native with Expo SDK 54 and TypeScript](https://docs.natively.dev/), and you can export the whole codebase. That is a genuine Tier 2 tool.

Meanwhile buildnatively.com is a separate, still-live product that does something completely different. Its own company description states that ["BuildNatively works by securely wrapping your website inside a mobile app using WebView technology, while extending it with native capabilities."](https://www.trustpilot.com/review/buildnatively.com) That is a Tier 4 wrapper.

They even have separate Trustpilot profiles with wildly different scores, 3.3 from three reviews for natively.dev against 4.8 from a hundred for buildnatively.com, which means anyone comparing "Natively reviews" is probably comparing two different companies without realising it.

So if someone tells you they built their app with "Natively," you still do not know whether they have a React Native codebase or a browser frame pointed at their website. The name is load-bearing for neither. This is why the rest of this article ignores what tools call themselves and asks four mechanical questions instead.

## Native vs Hybrid vs Cross-Platform vs Web App

These four terms get used interchangeably and they are not interchangeable. The distinction that matters to you is what ends up on the user's device.

| Approach | What runs on the device | Language you write | Can it reach the App Store? | Typical trade-off |
| --- | --- | --- | --- | --- |
| Native | Compiled binary using platform UI frameworks | Swift/Objective-C (iOS), Kotlin/Java (Android) | Yes | Best performance and platform feel, one codebase per platform |
| Cross-platform compiled | Compiled binary, platform-backed views | Dart (Flutter), JavaScript/TypeScript (React Native) | Yes | One codebase for both, small gap on platform-specific features |
| Hybrid / web-native container | Your web app inside a native runtime | HTML, CSS, JavaScript | Yes, if it adds real functionality | Fast to build from an existing web app, review risk if thin |
| Progressive web app (PWA) | A website with offline and install behaviour | HTML, CSS, JavaScript | No | No store approval needed, but no store presence either |
| WebView wrapper | A browser view pointed at your URL | None, you supply a website | Risky, see guideline 4.2 | Cheapest path, highest rejection risk |

The practical consequence: a PWA and a wrapper both start from a website, but a PWA is honest about not being in the store, and a wrapper is trying to get into it. Apple treats those two situations very differently, which the rejection section below covers.

## Does Native Actually Perform Better?

Usually yes, and the gap is widest exactly where you would expect: long lists, heavy screens, animation under load, and cold start.

The most useful evidence is not a benchmark, it is a customer complaint, because benchmarks rarely reflect real apps. An Adalo customer running a transport business asked the question directly in a February 2025 review: "The performance (especially on native Android) is unacceptable! Why is a Progressive Web App on the same device about 10 times faster than the native android app?"

That is one user's experience of one platform at one point in time, and Adalo's CEO responded publicly within days announcing React Native and database work, with a later reviewer reporting in February 2026 that "ever since November 2025, my apps have been significantly faster and more reliable." Both things are true: the gap was real, and it was addressable.

The general principle holds regardless. Every layer between your code and the operating system costs something. Native has none. Compiled cross-platform has one, and it is thin. A vendor runtime has one you do not control. A WebView has an entire browser engine.

For a simple app with a dozen screens, none of this will be visible to your users. For a data-heavy app with long scrolling lists, it will be the first thing they notice.

## Which Device Features Can Each Approach Reach?

This is the practical version of the performance question, and it matters more for most apps.

| Capability | Native | Cross-platform compiled | Vendor runtime | WebView wrapper | PWA on iOS |
| --- | --- | --- | --- | --- | --- |
| Camera and photo library | Full access | Full access, via framework modules | Whatever the vendor exposes | Limited, via bridge | Limited |
| Push notifications | Full | Full | Usually, often on a paid tier | Usually, via the wrapper | Limited on iOS |
| Offline operation | Full control | Full control | Vendor dependent | Poor, it is a website | Partial, via service worker |
| Background tasks | Full | Mostly | Rarely | No | No |
| Biometrics | Full | Full | Vendor dependent | Via wrapper features | No |
| Widgets, Live Activities, watch apps | Full | Partial or via native modules | No | No | No |
| Same-day support for new OS APIs | Yes | Waits for the framework | Waits for the vendor | No | No |

The bottom two rows are where the tiers separate most sharply, and they are the ones people discover late. If your product roadmap includes a widget, a watch app, or anything Apple announces at a future WWDC, the tier you pick today decides whether that is a sprint or a rebuild.

## The Four Questions That Settle Whether a Tool Is Native

Ignore the marketing copy and ask these four things. They are all verifiable from a vendor's own documentation, and together they put any tool in the right tier.

1. Does it produce a real store binary, an IPA or AAB, or does it produce a URL? This separates everything else from PWAs.
 2. What language is the interface layer written in? Swift and Kotlin are native. Dart and TypeScript are compiled or rendered to native views. HTML in a browser frame is not.
 3. Can you export the source code, and on which plan? This is the lock-in question, and the answer is frequently "yes, on a paid tier" rather than the unqualified "yes" on the homepage.
 4. Does your published app keep working if you stop paying? For several tools the answer is no, and they say so in their own FAQs.

## The Four Tiers of Native App Makers

Applying those four questions to all 13 tools produces this. Nothing here is a judgement about quality, only about what the tool actually does.

| Tool | Store binary? | Interface language | Source export | App survives cancellation? |
| --- | --- | --- | --- | --- |
| Superapp | Yes | Swift | Yes, full | Yes, you hold the code |
| Expo + React Native | Yes | TypeScript to native views | It is your source | Yes, MIT licensed |
| FlutterFlow | Yes | Dart | Basic $39/mo and above | Yes, if you exported |
| Draftbit | Yes | TypeScript to native views | Standard $12/mo and above | Yes, if you exported |
| Newly | Yes | TypeScript to native views | Yes, ZIP and GitHub | Yes, if you exported |
| Xcode + SwiftUI | Yes | Swift | It is your source | Yes |
| Bubble | Yes | React Native | Not found | No, see below |
| Adalo | Yes, IPA/AAB | React Native per its own docs | Not found | No |
| Thunkable | Yes | Not documented | Not documented | No, stated in its FAQ |
| Capacitor | Yes | HTML/CSS/JS in a native runtime | It is your source | Yes, MIT licensed |
| Median.co | Yes | None, wraps your website | No | No |
| BuildNatively | Yes | None, wraps your website | No | No |
| Glide | No | Not applicable, PWA | No | No |

## The Scorecard

Six factual criteria, each a yes or no drawn from the tool's own documentation rather than from our opinion. The score is simply how many a tool satisfies, so you can disagree with our weighting and still use the rows.

| Tool | Native source | Ships to App Store | Code export | Survives cancellation | Free tier | Both platforms | Score |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Superapp | Yes | Yes | Yes | Yes | Yes | No | 5 of 6 |
| Expo + React Native | No | Yes | Yes | Yes | Yes | Yes | 5 of 6 |
| Xcode + SwiftUI | Yes | Yes | Yes | Yes | Yes | No | 5 of 6 |
| FlutterFlow | No | Yes | Yes, paid tier | Yes | Yes | Yes | 5 of 6 |
| Draftbit | No | Yes | Yes, paid tier | Yes | Yes | Yes | 5 of 6 |
| Newly | No | Yes | Yes | Yes | No | Yes | 4 of 6 |
| Capacitor | No | Yes | Yes | Yes | Yes | Yes | 5 of 6 |
| Bubble | No | Yes | No | No | Yes | Yes | 3 of 6 |
| Adalo | No | Yes | No | No | Yes | Yes | 3 of 6 |
| Thunkable | No | Yes | No | No | Yes | Yes | 3 of 6 |
| Median.co | No | Yes | No | No | Yes | Yes | 3 of 6 |
| BuildNatively | No | Yes | No | No | Yes | Yes | 3 of 6 |
| Glide | No | No | No | No | Yes | Not applicable | 1 of 6 |

The scores cluster, which is the point. Almost everything reaching five satisfies the criteria that matter for keeping your app; almost everything at three fails the same two, export and survival. Superapp and Xcode lose their sixth point for the same reason, being Apple-only, which is a deliberate trade rather than a defect. Capacitor scores well on these criteria while being the least native thing here, which is a good reminder that a scorecard is a starting point and not a verdict.

## Decide in Five Questions

If you want to skip the comparison entirely, answer these in order and stop at your first yes.

1. Do you only need Apple platforms, and do you want to own real Swift? Superapp, Tier 1.
 2. Can you write TypeScript? Expo with React Native, free and open source, nothing on this page beats it on cost or control.
 3. Do you need iOS and Android from one visual project, and do you want the code? FlutterFlow at $39 a month, or Draftbit at $12 if budget is the constraint.
 4. Do you already have a Bubble web app? Bubble's React Native mobile, because your data and logic are already there.
 5. Do you have an established website and just want it in the store? A wrapper, and read the App Store rejection section first, because it applies to you more than anyone else on this page.

If none of those fit, you probably want internal tooling rather than a store app, and Glide is the best-reviewed product on this page for exactly that.

## Tier 1: Which Tools Generate Native Swift Source?

One, at the time of writing.

### Superapp

**Superapp** generates what it calls ["production-ready native Swift code from your descriptions,"](https://superapp.dev) and on the ownership question states plainly that "you fully own the code and can export it anytime." It runs in the browser, so the usual Mac requirement does not apply: asked whether you need one, the site answers ["No. You can use Superapp on the web without a Mac, and we take care of publishing to the App Store for you."](https://superapp.dev)

Pricing is a free tier with starter credits, then Pro at $25 a month for 50 credits, Business at $50 for 110, and Max at $100 for 230, with a $18 one-time add-on for 30 extra credits valid twelve months.

What the workflow actually looks like: you describe the app in the browser, Superapp generates the Swift, and publishing to the App Store is handled for you, which the site frames as its main differentiator, claiming to be "the only app builder that fully automates App Store bureaucracy, turning a painful process into two clicks with a rejection rate close to zero." Treat that last clause as a vendor claim rather than an audited figure, in the same way we treat Median's 98% approval rate, because neither is independently verified.

The credit model is the thing to understand before subscribing. Pro's 50 monthly credits are consumed by generation, so the practical question is not whether 50 is enough for one app but whether it is enough for one app plus the iterations that follow. The $18 top-up for 30 credits, valid twelve months, exists because that answer varies. Given that credit burn is the defining complaint across this entire tier, documented above for Draftbit and Newly, assume you will want the top-up rather than assuming you will not.

The Apple Developer Program at $99 a year is not included and is not mentioned on the pricing page, which is worth stating since we criticised other vendors for the same omission.

The pitfall: this is a credit-metered AI tool, and as the reviews section below shows, credit accounting is the single most common complaint across every AI-native builder in this category. Budget for iteration, not just for the first generation.

Who it is not for: anyone who needs Android. Superapp is Apple platforms only, and if you need both stores from one project you should be reading Tier 2 instead. It also has no Trustpilot, G2 or Capterra listing, so unlike every competitor on this page it cannot show you a third-party review score. We would rather say that than imply one exists. There is a fuller treatment in our guide to [the best AI app builder for native iOS apps](https://superapp.dev/blog/the-best-ai-app-builder-for-native-ios-apps-2026).

Why this tier is nearly empty is worth a sentence. Generating correct Swift that compiles, passes review and remains readable is a harder problem than generating React Native, because there is no JavaScript escape hatch and no runtime to absorb mistakes. Most tools solve the easier problem and describe it with the harder problem's vocabulary.

## Tier 2: Which Tools Compile to Native and Let You Keep the Code?

This is the tier most people should actually be shopping in. The output is a real store binary, the interface is backed by platform views, and you can walk away with the source.

### Expo and React Native

Both are [MIT licensed and free](https://github.com/expo/expo). Expo's own pricing page draws the line clearly: "Expo and the Expo SDK are free and open source (MIT license). EAS (Expo Application Services) is the cloud platform that builds, submits, updates, and monitors your apps, and it is where pricing applies."

EAS Free gives you 15 Android and 15 iOS builds with a low-priority queue and store submission, with updates to 1,000 monthly active users. Starter is $19 a month plus usage and includes $45 of build credit. Production is $199 a month plus usage with $225 of credit and a SOC 2 Type 2 report. Extra build concurrency is $50 each.

React Native holds 4.4 out of 5 from [143 reviews on G2](https://www.g2.com/products/react-native/reviews), the second-largest sample on this page.

The pitfall: EAS build minutes and concurrency are the real cost, not the subscription. A team shipping frequently on the free queue will spend more time waiting than building, and the jump from Starter to Production is a factor of ten.

Who it is not for: anyone who cannot write code. This is a framework, not a builder, and no amount of AI assistance changes that you are maintaining a TypeScript codebase.

### FlutterFlow

FlutterFlow is a visual builder that produces a Flutter and Dart project and deploys to both stores. Its homepage makes the anti-lock-in pitch directly: ["Export your code with the click of a button. No vendor lock-in."](https://www.flutterflow.io/)

That claim carries a plan condition the homepage does not mention. On [the pricing page](https://www.flutterflow.io/pricing), Code Download, APK Download and One-Click Store Deployment are all absent from the Free tier and present from Basic upward. Free is web publishing only, capped at two projects. Basic is $39 a month, Growth is $80 for the first seat, Business is $150 for the first seat. The page offers an annual toggle advertising roughly 25% off but does not display the annual figures, so we are not quoting one.

On G2 it holds 4.5 out of 5 from [30 reviews](https://www.g2.com/products/flutterflow/reviews), where one Lead Analyst wrote in April 2025: "I've been able to go from novice developer to having a live product in market in a very short amount of time."

The picture on [Trustpilot is very different](https://www.trustpilot.com/review/flutterflow.io), at 2.4 out of 5 from 22 reviews with 41% of them one-star. We read all 22, and the reason is specific enough to be worth stating: ten of them are complaints about support response rather than about the product. One reviewer in September 2026 opened with "I genuinely like building in FlutterFlow, the visual builder is powerful and it makes app development accessible," then explained that "it's now been over a week with zero response from FlutterFlow itself. Meanwhile my subscription auto-renewed, so I'm now paying a second month for a tool I can't fully use." Her closing line is the fairest summary of the split: "The product has real potential, which makes the lack of support all the more disappointing."

The substantive product criticism, where it exists, is about scale rather than capability. A reviewer in June 2026 wrote: "You may get a working prototype but thats it, zero scalability, horrible pipeline to deploy to production, the version control is the worst I had to face ever. Merging process takes literal hours and often it gets stuck." [sic]

The pitfall: version control and team workflow, which is exactly what several reviewers single out, and which only becomes visible after you are committed.

Who it is not for: solo builders who want to stay on a free plan, because Free cannot export code or publish to a store, so the effective entry price is $39 a month. If FlutterFlow is not the fit, we compare the field in [FlutterFlow alternatives](https://superapp.dev/blog/best-flutterflow-alternatives-in-2026-free-native-options).

### What FlutterFlow Still Does Well

It would be easy to read the Trustpilot score and write FlutterFlow off, and that would be wrong. It is the most mature visual builder in this comparison by a wide margin, it genuinely exports a real Flutter project that a Flutter developer can pick up and continue, and its component library and template set are the largest here. The 4.5 on G2 and the 4.4 from 85 reviews on [Capterra](https://www.capterra.com/p/249489/FlutterFlow/reviews/) reflect a product that works well for the people it fits.

If you want a visual builder, need both platforms, and have a developer available for the parts that get hard, FlutterFlow is the strongest option on this page and the reason our Tier 1 entry is Apple-only is that matching FlutterFlow's cross-platform breadth is genuinely difficult.

### Draftbit

Draftbit describes its output concretely: ["You can build native iOS and Android apps with React Native and Expo, browser web apps with Vite, and content websites with Astro,"](https://draftbit.com/faq/) and "a Draftbit project is a real React Native, Vite, or Astro codebase."

Export is real but tiered, and the tiering is easy to miss. The platform page promises "export your full source code to GitHub or download as a zip. No lock-in, ever." The FAQ then notes that "saving code edits needs Standard or higher," the Free tier has no code export at all, Standard is the first tier with full code editing and export, and Export to GitHub only arrives on Pro. Publishing has the same shape: "publishing to the App Store and Google Play needs Standard or higher and your own developer accounts."

Standard is $12 a month, Pro is $24, Team is $120. That makes Draftbit the cheapest genuine code-export path in this tier. On [G2](https://www.g2.com/products/draftbit/reviews) it holds 4.1 from 11 reviews, and an owner wrote in August 2026: "i like the fact that it is so easy to use and a very powerful platform." [sic]

The pitfall is credits, and it is the clearest pattern in Draftbit's review record: five of those eleven reviews raise AI credit cost or unpredictability, across the whole rating range. A founder rated it 3.5 in August 2026 and explained why: "My free credits ran out during the first build, and I did not have a clear estimate beforehand of how much each agent request would consume."

Who it is not for: anyone who wants a settled, long-established product. Nine of Draftbit's eleven G2 reviews are dated between June and September 2026, which is a very recent and concentrated sample, so the 4.1 average rests on a short window.

### Newly, formerly Natively

Newly is an AI prompt-to-app builder whose stack is documented rather than implied: React Native with Expo SDK 54, TypeScript, RevenueCat for payments, EAS Build for deployment. It says its apps are ["built with React Native and Expo, your apps compile to real iOS and Android native code, not webviews."](https://newly.app/)

Export is unambiguous and bidirectional: click the GitHub button and "Newly will create a repository with your complete source code," or download a ZIP.

Three things to know before you commit. There is no free tier: ["We don't offer a free tier. Newly starts at $25 USD per month for 50 credits,"](https://newly.app/faq) where one credit is one AI prompt. The iOS publishing route has an unusual requirement, in their own words: "For iOS, deploy to the App Store using Expo Launch, create a GitHub repository for your project, make it public, and follow the Expo Launch workflow." A public repository is a real consideration if your app contains anything you would rather not publish.

And its review record, while far too thin to average, is specific. It has 3.3 on [Trustpilot](https://www.trustpilot.com/review/natively.dev) from three reviews. The most detailed is a three-star review from March 2026 that describes the build stage failing after the credits were spent: "It built an app that doesn't compile to APK or AAB.But isnt that the main goal of this?" [sic] The same reviewer's closing sentence is the one worth weighing: "Natively saves time with the creating of MVP but then you end up spending lot of time building the actual production build which the website is supposed to handle." [sic] A second reviewer's complaint is also about credits, specifically that unused monthly prompts expire.

The pitfall: credits are consumed by failed fixes as well as successful ones, which is the recurring theme across this whole tier.

Who it is not for: anyone who needs to evaluate before paying, since there is no free tier, and anyone whose source cannot be in a public repository.

## What If You Need Android First?

This page is honest that its Tier 1 entry is Apple-only, so it owes Android-first readers a straight answer rather than a redirect.

There is no Android equivalent of Tier 1 in this comparison, meaning no tool here generates Kotlin source you can export the way Superapp generates Swift. If that is what you want, you are looking at Android Studio and Kotlin directly, which is free, requires no particular hardware beyond a reasonable computer, and carries the same learning cost that Xcode does on the Apple side.

For everything short of that, Tier 2 is the answer and it is a good one. FlutterFlow, Draftbit, Newly and Expo with React Native all produce genuine Android builds from the same project as iOS, and all four let you export. Google Play's developer registration is a $25 one-time fee rather than Apple's $99 a year, so Android is cheaper to reach.

One Android-specific caution from the review record: performance complaints in this category cluster on Android more than on iOS. The most pointed example is the Adalo customer asking why a progressive web app ran about ten times faster than the native Android build. If Android is your primary platform rather than a secondary one, weight Tier 2 over Tier 3 more heavily than an iOS-first reader would.

## Tier 3: Which Tools Ship a Real Binary but Keep the Code?

These produce genuine App Store apps. You simply cannot take the source with you, and in each case your live app depends on an active subscription.

### Bubble

Bubble is refreshingly direct about its output: ["Bubble uses React Native, a JavaScript framework, to create cross-platform mobile apps that work for iOS and Android out of the box."](https://bubble.io/blog/native-mobile-beta/) Its manual confirms the runtime, noting that "our current version of React Native will support: iOS devices running version 15.1 and later."

Native mobile entered public beta on 10 June 2025 and moved to paid plans on 1 October 2025. The consequence of not opting in was stated plainly at the time: ["If you don't opt in by then, your mobile apps will downgrade to a Free plan. This means: Existing live versions will no longer be supported, so users will no longer be able to access your mobile apps."](https://bubble.io/blog/native-mobile-pricing-2025/)

A paid plan is mandatory to ship: "a paid plan is necessary for deploying a live version of your app, which is required for testing with Apple Test Flight and Google Play and for publishing to the Apple App Store or Google Play Store." Billed annually, Starter is $59 a month with 5 build submissions, Growth is $209, Team is $549. Monthly rates are not published on the pricing page.

It is the most reviewed tool here by a wide margin: 4.4 from [166 on G2](https://www.g2.com/products/bubble/reviews) and 4.6 from [334 on Capterra](https://www.capterra.com/p/171359/Bubble/reviews/). Worth knowing that its Trustpilot profile sits far lower, around 1.7 across roughly 130 reviews, which is the widest three-way split on this page.

One honest gap: we could not find a single review on G2 or Capterra that evaluates Bubble's native mobile publishing. The feature is too new, and the review corpus is overwhelmingly about web apps. That is itself worth knowing, because it means the 4.4 and 4.6 averages tell you about Bubble as a web platform, not about the mobile capability you would be buying it for.

The recurring criticism is cost at scale rather than capability. A reviewer in March 2026, rating it 4 out of 5 and otherwise positive, wrote: "I had a case in which one of our products was loading 1 milion times per month, and costs to host this on bubble were 10x what we ended up paying when we rebuilt the same feature in full code (node.js, +render web service)." [sic] Bubble's workload-unit pricing model draws similar comments repeatedly.

The pitfall: workload units are hard to forecast, and your bill scales with usage in a way that subscription pricing elsewhere on this page does not.

Who it is not for: anyone starting fresh who only wants a mobile app. Bubble makes sense when you already have the web app and the mobile build is an extension of it.

### Adalo, and a contradiction worth reading twice

Adalo's marketing is emphatic that its output is not React Native. Its App Store publishing page promises ["real native builds compiled via Codemagic, not web wrappers, PWAs, or React Native bridges,"](https://www.adalo.com/products/app-store-publishing/) and its product page repeats the point: ["Real APK builds that run natively, not a React Native wrapper or PWA."](https://www.adalo.com/product/)

Adalo's own developer documentation says the opposite. The cross-platform page states: ["Our mobile builds use React Native. Anything on web can use React Native Web or React."](https://developers.adalo.com/docs/workflow/cross-platform/) The introduction adds that "you can use either React or React Native Web on web, but you must write React Native code for mobile," and tells component developers the docs assume "a working knowledge of both React and React Native."

Both of those are Adalo's words on Adalo's domains. Our reading is that Adalo genuinely compiles an IPA and an AAB, so it is a real store binary and not a PWA in disguise, but the interface layer is React Native, which makes the marketing line "not a React Native wrapper" difficult to defend. We are linking both sources so you can check for yourself rather than take our word for it.

The performance question this raises is not hypothetical. A CEO in the transport sector rated Adalo 2 out of 5 in February 2025 with a question that goes straight to it: "The performance (especially on native Android) is unacceptable! Why is a Progressive Web App on the same device about 10 times faster than the native android app?" Adalo's CEO replied publicly four days later announcing React Native improvements and database indexing work.

The most serious complaint in Adalo's review record is about data, from a COO who rated it 2 out of 5 in May 2025: "Literally 2 times I have lost properties from my collection. 2 weeks ago, around 70% of my database suddenly dissapeared, making my apps completly useless." [sic] The same review quotes Adalo's own explanation of an earlier incident: "We had a noisy tenant that created an exponentially increasing number of server calls against a huge database that depleted the server of memory."

In fairness, the more recent reviews suggest the rebuild worked. A reviewer in February 2026 rated it 5 out of 5: "Adalo used to be pretty average on stability and speed. The new team have changed that with Adalo 3.0, doing significant work on the backend infrastructure. Ever since November 2025, my apps have been significantly faster and more reliable."

Pricing is Free with no publishing, Starter at $36 a month billed annually or $43.20 monthly for one published app, Professional $52 annually, Team $160 annually. It holds 4.4 from only [7 reviews on G2](https://www.g2.com/products/adalo/reviews) and 3.5 from [25 on Capterra](https://www.capterra.com/p/207495/Adalo/reviews/), the weakest Capterra score in this comparison.

The pitfall: support responsiveness on hard problems, which is the single most repeated complaint in its review record.

Who it is not for: anyone whose app is the business rather than an accessory to it, at least until the 3.0 improvements have a longer track record.

### Thunkable

Thunkable makes the loudest native claim on this page. Its page title is "Vibe Code Native iOS & Android Apps," and its documentation opens with ["Thunkable is a no-code platform that empowers anyone to design, build, and publish native mobile and web apps, without writing a single line of code."](https://docs.thunkable.com/)

It also documents the claim least. We could not find any official statement anywhere in Thunkable's documentation of what its apps are actually built with, and there is no documented way to export your source code. Community threads speculate, and we are not going to repeat speculation as fact. The accurate statement is narrow: Thunkable does not document what its apps compile to, and documents no source export.

The subscription dependency is the sharpest thing in its FAQ, and it is stated outright: "you must maintain an active subscription for your published apps to remain active," and "if your subscription expires, any published apps will become unavailable for your end users." Your shipped app stops working for your users if you stop paying.

Prices as displayed in September 2026, with the page carrying a 50% promotional banner, so treat these as promotional rather than list: Free, Accelerator $19 monthly or $18 yearly, Builder $59 monthly or $37 yearly for a single live published app, Advanced $189 monthly or $99 yearly for unlimited.

On reviews, a caution about a comparison you will see elsewhere. Thunkable holds 4.4 from [40 reviews on G2](https://www.g2.com/products/thunkable/reviews) and 2.5 on [Trustpilot](https://www.trustpilot.com/review/thunkable.com), but the Trustpilot figure is six reviews spread across 2020 to 2025, with no common theme between them. That is too small to mean anything, and presenting it as a 4.4-versus-2.5 contradiction would be misleading. The more useful criticism is on G2, from a project manager who rated it 2.5 in December 2022: "I can't publish on Android anymore because of a limitation of thunkable regarding saving image on the device memory." A founder on the same platform gives the positive case: "I love that I do not need any coding or development experience prior to using Thunkable."

The pitfall: the Builder tier allows exactly one live published app, so a second app doubles your cost or forces the jump to Advanced.

Who it is not for: anyone building something they intend to maintain for years, because you cannot export it and it dies with the subscription.

## Tier 4: Which Tools Are Not Native at All?

Nothing in this tier is bad software. Each is being used by people who genuinely need it. They simply do not produce native apps, and two of them market as though they do.

### Glide

Glide is the only tool here that rules itself out, clearly and in writing. Its help centre states: ["Glide is a platform for creating professional software that connects your data and tools, without coding. It is built using Progressive Web App (PWA) technology, which means its apps cannot be published in traditional app stores like Google Play or Apple App Store."](https://help.glideapps.com/en/articles/9247733-publishing-glide-apps-to-an-app-store)

A second article is blunter still: ["publishing directly to the App Store or Google Play is not supported"](https://help.glideapps.com/en/articles/10021560-is-glide-able-to-push-to-app-store) and "Glide does not offer any native app publishing options." On the third-party wrapping workaround that people attempt, Glide says it "does not endorse or support this practice."

If your requirement includes an App Store listing, that settles it, and the honesty is worth respecting. Glide now runs two priced products: GlideOS at Free, $25, $50 and $125 a month, and Glide Classic at Explorer $19 a month annually, Maker $49, Business $199. It holds 4.7 from [820 reviews on G2](https://www.g2.com/products/glide-2023-07-10/reviews), the strongest score and by far the largest sample on this page, for software that is excellent at a different job.

What is striking in those reviews is that the app-store limitation comes up as a wish from satisfied users rather than as a dealbreaker from detractors. Four separate reviewers between 2022 and 2025 raise it, rating Glide between 3.5 and 5 stars while doing so. One put it simply in December 2025: "It doesn't support native app store publishing, which is a bit of a letdown." Another, rating it 5 out of 5, wrote: "If they can make the web app works as a Regular app and to be downloaded from App Store & Play Store."

The pitfall: none for its actual job, but if a stakeholder expects an App Store icon at the end of the project, establish that expectation on day one.

Who it is not for: consumer apps that need store distribution and discovery.

One warning if you are researching this yourself: the Capterra listings that come up for "Glide" are a real-estate e-signature product and an accounting workflow tool, both different companies. Several competitor blog posts quote those scores as if they belonged to the app builder. They do not.

### Median.co

Median turns a URL into a store app, and is upfront that WebView is the mechanism, describing itself as ["the webview app development platform trusted by the Fortune 500"](https://median.co/) that lets you "turn any URL into native iOS & Android apps."

Where it gets complicated is approval. The marketing promises certainty: the site advertises being "engineered for App Store Approval," claims a self-reported 98% approval rate, and offers to publish "with guaranteed app store approval."

Median's own blog tells readers the opposite risk applies to thin builds: ["If your app is a website wrapped in a webview with nothing native added, expect a Guideline 4.2 or 2.1 rejection,"](https://median.co/blog/how-to-appeal-to-app-store-review-after-app-store-rejection) and "Apple rejects apps that read as too thin, a plain website wrapped in a shell with nothing native added." Their own recommended fix is to add "real native functionality, such as push notifications, biometrics, or offline access."

Those two positions can be reconciled, since a guarantee attached to a full-service engagement is not the same as a guarantee attached to a self-serve build. But if you are self-serving a thin wrapper, the blog is the sentence that applies to you. Pricing is self-serve from $0, SMB from $7,200 and Enterprise from $18,000, with the billing period for the latter two not stated on the pricing page.

The pitfall: the guarantee you are reading about on the homepage is attached to the tier that starts at $7,200, not to the free self-serve one.

Who it is not for: anyone without an established, content-rich website already. The thinner your site, the worse your odds at review.

### BuildNatively

The wrapper half of the Natively name collision. Free with no binaries, Essential $19 a month or $12 billed yearly, Unlimited $49 or $32 yearly, and a $699 lifetime option, with App Store publishing as a service from $600. It holds 4.8 from [100 Trustpilot reviews](https://www.trustpilot.com/review/buildnatively.com), which is a real score from a real sample, and it reflects that the product does what it says for people who wanted a wrapper.

The pitfall: the same guideline 4.2 exposure as any wrapper, and the lifetime tier is only a bargain if the product outlives your need for it.

Who it is not for: anyone who described what they want as an "app" but actually meant a product with offline behaviour, device features and platform feel.

### Capacitor

Capacitor is the most intellectually honest tool in this tier, because it invented its own accurate label rather than borrowing one. It calls itself ["a cross-platform native runtime for web apps"](https://capacitorjs.com/) that "creates Web Native apps, providing a modern native container approach for teams who want to build web-first without sacrificing full access to native SDKs when they need it." Its documentation adds the line that tells you exactly what you are getting: "if it works in the browser, it probably works in a mobile app when using Capacitor."

It is MIT licensed and free. We found no Capacitor-published guidance on App Store rejection risk or guideline 4.2, which is a gap worth knowing about given that its output is the category Apple scrutinises most.

The pitfall: you are responsible for adding enough native capability to clear review, and Capacitor's documentation will not warn you about that.

Who it is not for: teams without an existing web app, since Capacitor's entire value is wrapping one you already have in a container you control.

## The Xcode Baseline: What Apple's Own Tools Cost

Worth stating plainly, because every tool on this page is priced against an alternative that costs nothing. [Xcode](https://developer.apple.com/xcode/) is free and "offers the tools you need to develop, test, and distribute apps for Apple platforms." Swift and SwiftUI are free. The Apple Developer Program is $99 a year, and Google Play is a $25 one-time fee, and you pay those regardless of which tool on this page you choose.

The real cost of the baseline is not money, it is a Mac and the months it takes to learn Swift. That is the entire value proposition of every product above: not that Apple's tools are expensive, but that they are slow to learn and require hardware you may not own.

The pitfall: none technically, but the opportunity cost is measured in months, and most people who choose this path and then abandon it have spent that time instead of shipping.

Who it is not for: anyone validating an idea. Learn Swift when you know the app is worth building, not to find out.

## Head to Head: The Five Comparisons People Actually Make

### Superapp vs Xcode

The same output, Swift, reached two ways. Xcode is free and gives you complete control, and the skill you build transfers to every Apple job you will ever have. It also requires a Mac and months before you ship anything. Superapp costs $25 a month, needs no Mac, and gets you to the App Store in the time it takes to describe the app, at the cost of credits and of trusting generated code you did not write. Pick Xcode if the app is a long-term commitment and you want the skill. Pick Superapp if the app is the point and the skill is not.

### Superapp vs FlutterFlow

The real decision for most iOS-first builders, and it turns on one question: do you need Android? If you do, this is over, because Superapp does not build it and FlutterFlow does. If you do not, the comparison is Swift you own against Dart you own, $25 a month against $39, and a tool with no public review record against one with 30 G2 reviews, 85 Capterra reviews and a 2.4 Trustpilot score driven by support complaints. FlutterFlow is the more proven product with the broader reach. Superapp produces the more platform-native output for Apple specifically.

### FlutterFlow vs Draftbit

Both export, both cover iOS and Android, and Draftbit is a third of the price. The difference is maturity against economics. FlutterFlow is the established visual builder with the larger component library and the larger user base, and it exports Dart. Draftbit exports React Native, starts at $12 a month, and its eleven G2 reviews are concentrated in a single recent quarter, so there is much less evidence about how it behaves over time. Draftbit is the better deal; FlutterFlow is the safer bet.

### Bubble vs Adalo

Two Tier 3 tools, both React Native underneath, neither exporting. Bubble is $59 a month billed annually against Adalo's $36, and Bubble has roughly 500 reviews across G2 and Capterra against Adalo's 32. But none of Bubble's reviews evaluate its mobile publishing, which is barely a year old, while Adalo has been publishing to stores for years and has the scars to show for it, including a documented data-loss incident and a performance rebuild. Choose Bubble if you already have a Bubble web app. Choose Adalo if mobile is the whole product and you want the tool that has been doing only that for longer.

### Median vs BuildNatively

Both wrap a website. BuildNatively is far cheaper at $12 a month billed yearly, or $699 once, and has a genuine 4.8 from 100 Trustpilot reviews. Median is enterprise-oriented, with self-serve starting free but its real offering, including the approval guarantee, starting at $7,200. The deciding factor is who handles App Store review. If you are confident your site is substantial enough to clear guideline 4.2 on its own, BuildNatively is the better value. If you want someone else to own that risk, that is what Median's higher tiers are selling.

## What the Marketing Says vs What the Documentation Says

The single most useful exercise when evaluating anything in this category. In four cases the two disagree, and in each one the documentation is the version you will live with.

| Tool | The marketing claim | What its own documentation says |
| --- | --- | --- |
| Superapp | "Production-ready native Swift code from your descriptions" | Consistent, and "you fully own the code and can export it anytime" |
| Adalo | "Real native builds... not web wrappers, PWAs, or React Native bridges" | "Our mobile builds use React Native" |
| Median.co | "Guaranteed app store approval", self-reported 98% rate | "If your app is a website wrapped in a webview with nothing native added, expect a Guideline 4.2 or 2.1 rejection" |
| FlutterFlow | "Export your code with the click of a button. No vendor lock-in." | Code Download is absent from the Free tier, so export starts at $39 a month |
| Draftbit | "Export your full source code to GitHub or download as a zip. No lock-in, ever." | "Saving code edits needs Standard or higher", GitHub export is Pro and above |
| Thunkable | "Vibe Code Native iOS & Android Apps" | No published statement of what its apps are built with |
| Newly | "Your apps compile to real iOS and Android native code, not webviews" | Accurate, the stack is React Native with Expo SDK 54, though "compile to native" is looser than React Native's own "rendered with native code" |
| Glide | Makes no native claim | "Its apps cannot be published in traditional app stores" |
| Capacitor | "A cross-platform native runtime for web apps" | Consistent, "if it works in the browser, it probably works in a mobile app" |

Two of these are outright contradictions, Adalo and Median. Two are unmentioned conditions rather than contradictions, FlutterFlow and Draftbit, where the export promise is real but arrives at a price the homepage does not state. One, Thunkable, is an absence rather than a conflict. And three, Glide, Capacitor and Superapp, say the same thing in both places, which is worth crediting.

## The Two Contradictions, Side by Side

Worth isolating, because these are the only cases on this page where a vendor's own two sources cannot both be true.

**Adalo.** The marketing page says the output is "not a React Native wrapper or PWA." The developer documentation says "our mobile builds use React Native." Both are published by Adalo. Our reading: the IPA and AAB are real, so "not a PWA" holds, but "not React Native" does not survive its own docs. The likely intent is to distinguish React Native from a WebView, which is a fair distinction badly worded, but as published it tells a buyer something untrue about the stack they are adopting.

**Median.** The homepage sells "guaranteed app store approval." The company blog tells readers a thin wrapper should "expect a Guideline 4.2 or 2.1 rejection." These reconcile if the guarantee attaches only to the full-service tier starting at $7,200, which the pricing page implies but does not state. A self-serve customer reading the homepage would reasonably believe the guarantee covers them.

Neither is disqualifying. Both are reasons to read the documentation before the pitch, which is the advice this whole article exists to give.

## What Does Apple Actually Reject?

This is where the tier you chose stops being academic. Apple's guideline 4.2, Minimum Functionality, opens with the sentence every wrapper vendor has read: ["Your app should include features, content, and UI that elevate it beyond a repackaged website. If your app is not particularly useful, unique, or 'app-like,' it doesn't belong on the App Store."](https://developer.apple.com/app-store/review/guidelines/)

Three more clauses from the same document matter to anyone using a builder:

- 4.2.2: "Other than catalogs, apps shouldn't primarily be marketing materials, advertisements, web clippings, content aggregators, or a collection of links."
 - 4.2.7(e): "Thin clients for cloud-based apps are not appropriate for the App Store."
 - 4.2.6, which targets app-generation services specifically: "Apps created from a commercialized template or app generation service will be rejected unless they are submitted directly by the provider of the app's content. These services should not submit apps on behalf of their clients and should offer tools that let their clients create customized, innovative apps that provide unique customer experiences."

That last one is the clause to read twice if you are choosing a builder that submits on your behalf. The requirement is that the app is submitted by the provider of the content, meaning you, from your own developer account.

A correction while we are here, because this site has repeated it and so has most of the industry. The widely quoted line that "including iOS features such as push notifications, Core Location, and sharing do not provide a robust enough experience" is not in Apple's published guidelines. We checked the live document: the strings "Core Location" and "WebView" do not appear anywhere in it. That sentence comes from Apple's older rejection-letter boilerplate and a retired Common App Rejections page. The claim may still describe how reviewers behave, and Median's own blog independently recommends adding push, biometrics or offline access for exactly that reason, but it should not be attributed to the guidelines, and we will not do so here. The nearest published statement is 4.5.4: "Push Notifications must not be required for the app to function."

### How often does Apple actually reject?

Often enough that it belongs in your planning. Apple's [2025 App Store Transparency Report](https://www.apple.com/legal/app-store/transparency/2025/) puts real numbers on it: of 9,100,620 app submissions reviewed, 2,093,244 were rejected.

| Rejection category | Submissions rejected, 2025 |
| --- | --- |
| Performance | 1,354,418 |
| Legal | 495,673 |
| Design | 415,532 |
| Business | 283,820 |
| Safety | 151,159 |
| Other | 4,145 |

The Design row is the one to watch, because Apple's own footnote explains what it contains: "The Design category includes guidelines that prohibit copycat apps, apps with minimum functionality, and spam." Minimum functionality is 4.2. Apple does not publish a rejection count for 4.2 on its own, so 415,532 is the closest available figure and it is an upper bound covering three separate problems. Note also Apple's caveat that a submission can be rejected under more than one guideline, which is why the categories sum to more than the total.

For context on scale, Apple's newsroom put the same year this way: the review team ["evaluated more than 9.1 million app submissions"](https://www.apple.com/newsroom/2026/05/the-app-store-stopped-over-2-point-2-billion-usd-in-fraudulent-transactions-in-2025/) and rejected "over 2 million," including "over 371,000 submissions that copied other apps, were found to be spam, or otherwise misled users."

### Rejection risk by tier

| Tier | Guideline exposure | Practical risk |
| --- | --- | --- |
| Tier 1, native source | Normal app review | Lowest, the output is indistinguishable from hand-written native |
| Tier 2, compiled cross-platform | Normal app review | Low, these frameworks ship a large share of the App Store |
| Tier 3, vendor binary | 4.2.6 if the vendor submits for you | Low to moderate, submit from your own account |
| Tier 4, wrapper | 4.2, 4.2.2, 4.2.7(e) | Highest, and the vendor's own blog will tell you so |
| PWA | Not applicable | No store presence at all |

## Why Builder-Made Apps Get Rejected, and the Fix

Most rejections in this category come from a short list, and none of them require abandoning your tool.

| Why it was rejected | Guideline | The fix |
| --- | --- | --- |
| The app is mostly your website in a shell | 4.2 | Add real functionality that works without the browser: offline data, device features, native navigation |
| It is a collection of links or marketing material | 4.2.2 | Build around a task the user performs, not around content they read |
| The builder submitted it on your behalf | 4.2.6 | Submit from your own Apple Developer account, in your own name |
| It is a thin client for something running elsewhere | 4.2.7(e) | Move meaningful work into the app itself |
| It closely resembles apps already on the store | 4.3(b) | Differentiate the experience, not just the branding |
| The reviewer could not log in | Not a 4.x issue at all | Supply working demo credentials in App Store Connect, the most common avoidable rejection |

The last row is worth emphasising because it has nothing to do with which tool you used and it catches people repeatedly. Apple's reviewer is a person who needs to get into your app. If your app requires an account, give them one.

## What Happens at App Store Review?

Knowing the sequence removes most of the anxiety, and it explains why the 4.2.6 clause matters so much.

You need an Apple Developer Program membership at $99 a year, in the name of whoever owns the app, and that account is what submits. You create the app record in App Store Connect, upload a build, supply metadata, screenshots and a privacy disclosure, and submit for review. A human reviewer opens your app, uses it, and checks it against the guidelines.

Where builder-made apps run into trouble is almost always one of three places. The app is thin, so 4.2 applies. The app was submitted by the tool vendor rather than by you, so 4.2.6 applies. Or the app requires a login with no way for the reviewer to get in, which is a mundane and extremely common rejection that has nothing to do with which tool you used.

Rejection is not fatal and it is not rare. Apple reviewed 9.1 million submissions in 2025 and rejected 2.09 million of them, and its own footnote notes that "apps may be submitted to App Review multiple times before they are approved for release." A rejection is a message telling you what to fix, and most are fixed in a day.

The tier you are in changes the odds rather than the process. Tier 1 and Tier 2 apps are ordinary apps to a reviewer. Tier 4 apps are the category the guideline was written about.

## The Complaint Nobody Had Three Years Ago: Credit Burn

Reading every review we could find across these tools surfaced a pattern worth naming, because it cuts across the AI-native builders and is absent from the older ones.

The drag-and-drop generation, Adalo, Thunkable, Glide and Bubble, generates complaints about performance, support response and subscription pricing. Those are familiar software complaints. The AI-native generation, Draftbit, Newly and FlutterFlow's AI features, generates a different one entirely: users cannot predict what an action will cost, and failed actions consume credits anyway.

The evidence is consistent across three separate products. Five of Draftbit's eleven G2 reviews raise credit cost or opacity, and they span the full rating range including five-star reviewers, which makes it a design complaint rather than disgruntlement. Two of Newly's three Trustpilot reviews are about credit accounting, one describing credits consumed by fixes that did not fix anything, the other about unused monthly prompts expiring. A FlutterFlow reviewer's billing dispute concerned credits for a feature that did not work.

The structural issue is that a credit is charged for an attempt, not for a result. When a traditional builder fails to do what you asked, you have lost time. When an AI builder fails, you have lost time and money, and you still need to pay again to try the fix.

| Tool | Credit model | What reviewers report |
| --- | --- | --- |
| Superapp | 50 credits on Pro $25/mo, top-ups $18 for 30 | No third-party review record exists, so we cannot report one |
| Draftbit | 5,000 starter credits, then metered | 5 of 11 G2 reviews raise credit cost or unpredictability |
| Newly | 1 credit per prompt, 50 on the $25 tier | 2 of 3 Trustpilot reviews raise credit accounting |
| FlutterFlow | Lite credits per tier, plus AI request caps | Billing and refund disputes in 3 of 22 Trustpilot reviews |
| Adalo, Bubble, Thunkable, Glide | Subscription and usage based, not AI credits | Complaints are about performance, support and pricing instead |

Practical advice that applies whichever of these you pick: assume your first working build costs several times the credits the demo suggests, and check before subscribing whether unused credits roll over or expire.

## Can AI Actually Write Production Swift?

This deserves a straight answer, because most of this page's Tier 1 and Tier 2 tools are AI-driven and the marketing in this category is uniformly breathless.

What the review record shows is that AI builders are good at the first eighty per cent and expensive at the last twenty. The most detailed public account of that gap is the Newly reviewer quoted earlier, who got a working preview and then hit a wall: "It works in the preview. Used up all credits, one left. Lets build the project APK.Oh wait the build fails, now got no credits left." [sic] His conclusion generalises beyond that one tool: "Natively saves time with the creating of MVP but then you end up spending lot of time building the actual production build which the website is supposed to handle." [sic]

That is the honest shape of the category in 2026. Generating something that runs is largely solved. Generating something that builds, signs, passes review and survives contact with real users is where the remaining work, and the remaining credits, go.

The practical implication for choosing: weight code export heavily. If the AI takes you eighty per cent of the way and stalls, a tool you can export from lets a developer finish the job for a few hours of their time. A tool you cannot export from leaves you with an eighty-per-cent app and no way to finish it.

## Why Trustpilot and G2 Disagree So Violently

You will notice the review table below contains some startling gaps. FlutterFlow is 4.5 on G2 and 2.4 on Trustpilot. Thunkable is 4.4 and 2.5. Bubble is 4.4 on G2, 4.6 on Capterra and roughly 1.7 on Trustpilot.

Having read the underlying reviews rather than just the averages, the explanation is not that one platform is lying. The two sites are measuring different things.

G2 and Capterra reviews are mostly recruited, often through vendor campaigns, and they are written by people evaluating a product against its job. Trustpilot is where people go when something has gone wrong and they want it on the record. So Trustpilot samples are small and self-selected by grievance, and they skew heavily toward one specific grievance: support.

FlutterFlow demonstrates this precisely. Ten of its 22 Trustpilot reviews are about support non-response, and several of those reviewers explicitly praise the product in the same breath. Its positive Trustpilot reviews also centre on support, naming individual support staff who helped. That is not a product score at all, it is a support-experience score, and it is inconsistent rather than uniformly bad.

The practical read: use G2 and Capterra to judge whether a product does its job, and use Trustpilot to judge what happens when you need help. Weigh the second one heavily if you are non-technical, because you will need help.

## What Do Real Users Rate These Tools?

Scores with their sample sizes, because a 4.8 from four reviews and a 4.4 from 334 are not comparable claims.

| Tool | G2 | Capterra | Trustpilot | Sample worth trusting? |
| --- | --- | --- | --- | --- |
| Superapp | No listing | No listing | No listing | None exists, stated plainly |
| Glide Classic | 4.7 (820) | No valid listing | Not found | Yes, only statistically meaningful average here |
| Bubble | 4.4 (166) | 4.6 (334) | ~1.7 (~130) | Yes on G2 and Capterra, but none of it covers mobile |
| React Native | 4.4 (143) | Not found | Not found | Yes, though it is a framework not a builder |
| FlutterFlow | 4.5 (30) | 4.4 (85) | 2.4 (22) | Capterra yes, Trustpilot is a support-experience score |
| Thunkable | 4.4 (40) | 4.4 (8) | 2.5 (6) | G2 only, Trustpilot n=6 across five years is too thin |
| Draftbit | 4.1 (11) | Not found | Not found | Marginal, 9 of 11 are from a single recent quarter |
| Adalo | 4.4 (7) | 3.5 (25) | Not found | Capterra only, and it is the weakest score here |
| Newly | Not found | Not found | 3.3 (3) | No, three reviews cannot produce an average |
| BuildNatively | Not found | Not found | 4.8 (100) | Yes, for a wrapper product |

Two patterns are worth naming. The highest score on this page belongs to Glide, a tool that cannot do the thing this page is about, which is a useful reminder that review scores measure satisfaction with a job rather than fitness for yours. And the two tools with the largest samples, Glide and Bubble, are both products where the mobile-native capability is either absent or too new to have been reviewed at all.

## What Does Three Years Actually Cost?

The following is our own arithmetic at September 2026 list prices, not a vendor figure. It covers 36 months of the cheapest tier that can publish to the App Store, plus three years of the Apple Developer Program at $99 a year. It excludes AI credit top-ups, EAS build overages and Bubble workload units, all of which are usage-based and none of which we can predict for you.

| Tool | Cheapest publishing tier | 36 months of subscription | Plus Apple Developer | Three-year total |
| --- | --- | --- | --- | --- |
| Superapp | Pro $25/mo | $900 | $297 | $1,197 |
| Xcode + SwiftUI | Free | $0 | $297 | $297 |
| Expo + React Native | EAS Free | $0 | $297 | $297 |
| Capacitor | Free | $0 | $297 | $297 |
| Draftbit | Standard $12/mo | $432 | $297 | $729 |
| BuildNatively | Essential $12/mo yearly | $432 | $297 | $729 |
| Newly | $25/mo | $900 | $297 | $1,197 |
| Adalo | Starter $36/mo annual | $1,296 | $297 | $1,593 |
| Thunkable | Builder $37/mo yearly | $1,332 | $297 | $1,629 |
| FlutterFlow | Basic $39/mo | $1,404 | $297 | $1,701 |
| Bubble | Starter $59/mo annual | $2,124 | $297 | $2,421 |
| Median.co | SMB from $7,200 | Not published per period | $297 | Cannot be calculated |
| Glide | Cannot publish to stores | Not applicable | Not applicable | Not applicable |

Two observations. The spread between the cheapest paid option that exports code, Draftbit at $729, and the most expensive, Bubble at $2,421, is about $1,700 over three years, which is less than a week of contract development, so cost should probably not be your deciding factor. And the free options genuinely are free, because the $297 Apple charge is unavoidable no matter what you choose.

The more important number is the one nobody prices: what it costs to rebuild if you picked a tool you cannot export from and outgrew it.

## Can You Export Your Code?

The single most consequential column, and the one most often qualified in the small print.

| Tool | Export available? | The condition nobody mentions on the homepage |
| --- | --- | --- |
| Superapp | Yes, full Swift export | None stated |
| Expo + React Native | Not applicable, it is your repository | MIT licensed |
| Capacitor | Not applicable, it is your web project | MIT licensed |
| Draftbit | Yes | Free tier cannot export, Standard $12/mo for export, GitHub only on Pro $24/mo |
| Newly | Yes, ZIP and GitHub | App Store route asks for a public repository |
| FlutterFlow | Yes | Not on Free, requires Basic $39/mo or higher |
| Bubble | Not found | No documented export |
| Adalo | Not found | No documented export |
| Thunkable | Not documented | No documented export |
| Median.co | No | You keep the website, not an app codebase |
| BuildNatively | No | You keep the website, not an app codebase |
| Glide | No | Not applicable |

## What Happens If You Stop Paying?

Ask this before you ship, not after you have users. The answers are in the vendors' own documentation and they are not the same.

| Tool | What happens to a live, published app |
| --- | --- |
| Superapp | You hold exported Swift, so the app is yours to maintain |
| Expo, React Native, Capacitor | Open source, nothing to cancel |
| FlutterFlow, Draftbit, Newly | Fine if you exported, which is why the export tier matters |
| Bubble | Mobile apps downgrade to Free and live versions stop being supported |
| Thunkable | "If your subscription expires, any published apps will become unavailable for your end users" |
| Adalo | Publishing is tied to a paid plan |
| Median.co, BuildNatively | Wrapper stops being maintained, your website is unaffected |
| Glide | Not applicable, no store app exists |

## What Does It Cost to Switch Later?

Nobody plans to migrate, and a meaningful share of people do. The cost depends entirely on which tier you started in.

From Tier 1 or Tier 2, migration is a normal engineering task. You have a Swift, Flutter or React Native codebase, and a developer can continue it, refactor it, or port pieces of it. Your App Store listing, reviews and ranking survive, because you are shipping a new build of the same app rather than a new app.

From Tier 3, there is no migration. There is only a rebuild. You cannot export from Bubble, Adalo or Thunkable, so moving means recreating every screen and every workflow somewhere else from scratch, while the original keeps running and keeps costing.

From Tier 4, migration is usually easy for the wrong reason: there was never much app to move, only a website that still exists.

This is why the export column matters more than the price column. A $12 a month tool you can leave is cheaper over five years than a $36 a month tool you cannot, even before you count the rebuild.

## What About Security, Compliance and Teams?

Three considerations that only surface once an app is real.

Compliance documentation is thin across this category. Expo publishes a SOC 2 Type 2 report on its Production tier at $199 a month, which is the only formal compliance artifact we found documented at a named price in this comparison. If you are selling into enterprises or handling regulated data, that gap is worth raising with any vendor before you build.

Team collaboration is priced as a premium almost everywhere. FlutterFlow gates real-time collaboration behind Growth at $80 for the first seat and $55 for the second. Draftbit charges $8 per extra seat on Standard and $16 on Pro, with Team at $120 for ten seats. Bubble includes one app editor on Starter and two on Growth. If more than one person will touch the project, price the seats before you price the plan.

Source control is the sharpest divide. Tier 1 and Tier 2 tools that export to GitHub give you ordinary version history, branching and review. Tier 3 tools give you whatever the vendor's own versioning provides, and the most substantive FlutterFlow criticism we found was about exactly this, with one reviewer calling its version control "the worst I had to face ever" and describing merges that "take literal hours." If your team already works in Git, check what the tool does about branches before committing.

## Pick It or Skip It

One reason to choose each tool, one reason to walk away.

| Tool | Pick it if | Skip it if |
| --- | --- | --- |
| Superapp | You want real Swift you own, without a Mac | You need Android, or you want a public review record |
| Expo + React Native | You can write TypeScript and want total control | You cannot code |
| FlutterFlow | You need both platforms from one visual project | You need responsive support, or you want to stay free |
| Draftbit | You want the cheapest real code export at $12/mo | You want a long, settled track record |
| Newly | You want to prompt an MVP and keep the repo | You need a free trial, or a private repository |
| Xcode + SwiftUI | You are committing to Apple development properly | You are validating an idea and need speed |
| Bubble | You already have a Bubble web app | You are starting fresh and only need mobile |
| Adalo | You want drag-and-drop publishing today | Your app is the business, not an accessory to it |
| Thunkable | You want blocks-based building as a beginner | You want to own or export anything |
| Capacitor | You have a web app and want it store-ready | You have no web app yet |
| Median.co | You have a content-rich site and want services | Your site is thin, review will notice |
| BuildNatively | You want the cheapest wrapper that works | You actually wanted an app, not a website in a shell |
| Glide | You are building internal tools over data | Anyone expects an App Store listing |

## Which Native App Maker Should You Choose?

| If you are | Choose | Why |
| --- | --- | --- |
| Shipping iOS only and want to own real Swift | Superapp | Only Tier 1 option, full source export, no Mac needed |
| A developer who wants maximum control for nothing | Expo + React Native | MIT licensed, free, you own everything |
| Wanting iOS and Android from one visual project | FlutterFlow | Mature visual builder, real Dart export on Basic and above |
| On the tightest budget but still want the code | Draftbit | $12/mo is the cheapest genuine export path here |
| Prompting an app into existence and keeping the repo | Newly | Documented React Native stack, bidirectional GitHub |
| Already deep in a Bubble web app | Bubble | React Native mobile from the project you already have |
| Building internal tools over a spreadsheet | Glide | Best-rated here, as long as you accept no App Store |
| Turning an existing website into a store app | Median.co | Honest about WebView, read their own 4.2 warning first |
| Learning to build Apple apps properly | Xcode + SwiftUI | Free, and the skill outlasts every subscription here |

## Which Tool Suits Which Kind of App?

| App type | Best fit | Why |
| --- | --- | --- |
| Consumer iOS app with platform polish | Superapp | Native Swift means platform behaviour comes for free |
| Cross-platform consumer app | FlutterFlow or Expo | One codebase, both stores, real export |
| Startup MVP to validate an idea fast | Newly or Draftbit | Prompt to store quickly, keep the repo if it works |
| Internal business tool over a spreadsheet | Glide | Purpose-built for it, no store approval needed |
| Mobile companion to an existing web product | Bubble or Capacitor | Reuses the logic and data you already have |
| Content or commerce site that needs an app icon | Median.co | Wrapper is the honest fit, add native features for review |
| Long-lived app you will maintain for years | Xcode, Expo, or any Tier 1 or 2 exporter | Anything you cannot export becomes a rebuild later |

## Which Tool Covers Which Devices?

| Tool | iPhone | iPad | Android | Mac | Web |
| --- | --- | --- | --- | --- | --- |
| Superapp | Yes | Yes | No | Yes, Apple platforms | No |
| Expo + React Native | Yes | Yes | Yes | Via React Native macOS | Yes |
| FlutterFlow | Yes | Yes | Yes | Via Flutter desktop | Yes |
| Draftbit | Yes | Yes | Yes | No | Yes, via Vite |
| Newly | Yes | Yes | Yes | No | No |
| Xcode + SwiftUI | Yes | Yes | No | Yes | No |
| Bubble | Yes | Yes | Yes | No | Yes |
| Adalo | Yes | Yes | Yes | No | Yes |
| Thunkable | Yes | Yes | Yes | No | Yes |
| Capacitor | Yes | Yes | Yes | Via Electron | Yes |
| Median.co | Yes | Yes | Yes | No | Source is your site |
| BuildNatively | Yes | Yes | Yes | No | Source is your site |
| Glide | Installable PWA | Installable PWA | Installable PWA | Browser | Yes |

If iPad specifically is your target, we go deeper in [best app builders for iPad apps](https://superapp.dev/blog/best-app-builders-for-ipad-apps-2026).

## How This Category Changed in 2025 and 2026

Useful context if you are comparing this page against an article written eighteen months ago, because several of the most-repeated claims in this category are now out of date.

| When | What changed | Why it matters |
| --- | --- | --- |
| February 2025 | Adalo's CEO publicly announced React Native improvements and database indexing after performance complaints | The performance criticism you will find in older reviews was acknowledged, not ignored |
| 10 June 2025 | Bubble launched native mobile publishing in public beta, built on React Native | Older articles saying "Bubble cannot make native mobile apps" are simply wrong now |
| 1 October 2025 | Bubble's free mobile deployment window closed and mobile moved to paid plans | Apps not migrated to a paid plan lost support for their live versions |
| November 2025 | Adalo 3.0 backend work landed, with reviewers reporting speed and reliability gains from that month | The 2024 and early-2025 Adalo reviews describe a different product |
| November 2025 | Glide restructured into GlideOS and Glide Classic with separate pricing | Any single "Glide pricing" figure you see elsewhere is probably for the wrong product |
| 2026 | natively.dev rebranded to Newly at newly.app, while buildnatively.com continued as a separate WebView product | "Natively" in an older article may mean either of two unrelated products |
| May 2026 | Apple published its 2025 transparency figures: 9.1 million submissions, 2.09 million rejected | The current authoritative rejection numbers, superseding 2024 figures |

The pattern across all of it is that this category moves fast enough that a comparison article ages badly within a year. Check the date on anything you read about these tools, including this page.

## A Twenty-Minute Evaluation Checklist

Run this on any tool in this category, including ones not on this page, before you build anything.

1. Open the pricing page and find the cheapest tier that publishes to the App Store. It is frequently not the one advertised as the entry price.
 2. Search the pricing page for "export" or "code download" and note which tier it appears on.
 3. Open the developer documentation, not the marketing site, and search for "React Native", "Flutter", "Swift" and "WebView". What you find there is the real answer to what it builds.
 4. Search the FAQ or terms for "cancel", "expire" and "subscription" and find out what happens to a published app.
 5. Check whether credits roll over or expire, and whether a failed action consumes one.
 6. Look up the tool on G2 or Capterra for the product verdict, and on Trustpilot for the support verdict, and note the sample size on each.
 7. Check whether the vendor submits to the App Store on your behalf. If so, read guideline 4.2.6 before agreeing.
 8. Count the seats you will need and price them, because collaboration is a premium tier almost everywhere.

If a tool fails step three, meaning you cannot determine what it builds from its own documentation, that is a finding in itself.

## Questions to Ask Before You Commit

Send these to a vendor's support before you subscribe. The answers, and the speed of them, tell you as much as the product page does.

- What language is my app's interface actually written in, and can you point me at the documentation that says so?
 - On which plan can I export my source code, and does that export include the backend and the build configuration?
 - If I cancel, what happens to the version already live in the App Store?
 - Who submits the app to Apple, me from my own developer account, or you?
 - Do unused credits roll over, and are credits consumed when a generation fails?
 - What is your typical first-response time on a support ticket?

That last question is not filler. Support response is the single most common complaint across every review platform in this category, and it is the one thing you cannot assess from a free trial.

## Where Superapp Fits, and Where It Does Not

As a disclosure, Superapp is our product, so weigh this section accordingly.

Superapp sits in Tier 1 because it generates native Swift source and lets you export it, and it removes the Mac requirement by running in the browser. On this page's specific axis, what the tool actually produces, that is a real difference rather than a marketing one, and it is the only reason Superapp ranks first here.

It is not the right answer for everyone on this page, and pretending otherwise would undermine the whole point of the article:

- If you need Android, Superapp does not build it. FlutterFlow, Draftbit, Newly and Expo all do, from one project.
 - If you can already write TypeScript, Expo and React Native give you more control for nothing, and you should take that deal.
 - If you want a proven track record measured in public reviews, Superapp has no G2, Capterra or Trustpilot listing, while Bubble has 500 reviews across two sites and Glide has 820 on one. That is a legitimate reason to prefer them, and we have not manufactured a score to fill the gap.
 - Superapp is credit-metered, and the credit-burn complaints documented above are a category-wide pattern. We would be surprised if we were immune to it.
 - If your goal is genuinely to put your existing website in the store and you accept the review risk, a wrapper is cheaper and faster than anything in Tier 1 or 2.

## Mistakes to Avoid When Choosing a Native App Maker

- Reading "native" on a homepage and stopping there. Check the developer documentation instead, which is where Adalo's React Native dependency and Thunkable's undocumented stack both become visible.
 - Assuming "no vendor lock-in" means the free plan exports. On FlutterFlow and Draftbit it does not.
 - Forgetting the $99 a year Apple Developer Program, which no subscription on this page includes.
 - Letting a vendor submit to the App Store on your behalf without checking guideline 4.2.6, which requires submission by the provider of the content.
 - Comparing review scores without their sample sizes. Thunkable's 2.5 on Trustpilot is six reviews across five years, and treating that as a verdict is a mistake we see repeatedly in comparison articles.
 - Budgeting for the subscription but not for the credits, which is the most common complaint across every AI-native builder here.
 - Shipping on a tool whose app dies when the subscription lapses, without knowing that is the deal.
 - Treating a PWA as a store strategy. Glide is clear that it is not.

## Where This Debate Is Happening

If you want unfiltered opinion rather than vendor copy, these are the threads people in this category actually read. Each covers the same decision this article does, from builders who have shipped.

- [What is the best and most cost effective no code app builder for web and mobile apps?](https://reddit.com/r/nocode/comments/1pbsiuz/what_is_the_best_and_most_cost_effective_no_code) on r/nocode
 - [Best "no code" app builder](https://reddit.com/r/iOSProgramming/comments/17sddy3/best_no_code_app_builder) on r/iOSProgramming
 - [Building an iOS app, no code. Best platform?](https://reddit.com/r/iosdev/comments/1mmv5y8/building_an_ios_app_no_code_best_platform) on r/iosdev
 - [Which no-code app builder should I use for Android + iOS?](https://reddit.com/r/vibecoding/comments/1s8kcl5/which_nocode_app_builder_should_i_use_for_android) on r/vibecoding

## Native App Maker Terms, Defined

**Native app**: an app written in the platform's own language, Swift or Objective-C on iOS, Kotlin or Java on Android, compiled to a binary that runs directly on the device.

**Cross-platform compiled**: one codebase producing real store binaries for both platforms, as Flutter and React Native do.

**Platform-backed views**: React Native's term for UI components that map to the same views a Swift or Kotlin app would use.

**PWA, progressive web app**: a website with offline support and an install prompt. No store listing.

**WebView**: a browser component embedded in an app. A "wrapper" is an app that is mostly just a WebView pointed at a website.

**IPA and AAB**: the packaged app files submitted to the App Store and Google Play respectively.

**Guideline 4.2**: Apple's Minimum Functionality rule, the one that rejects repackaged websites.

**Guideline 4.2.6**: Apple's rule on apps built by template or app-generation services, which must be submitted by the content's provider.

**EAS**: Expo Application Services, the paid cloud build and submission layer over the free Expo framework.

**Credit**: a unit of AI work, typically one prompt or one agent request. Consumed whether or not the result was useful.

**Workload unit**: Bubble's usage-based billing measure, charged on server work rather than on seats.

**Code export**: the ability to download your project's source and continue it elsewhere. The difference between migrating and rebuilding.

**Vendor lock-in**: the state of being unable to take your app elsewhere because you cannot export the source.

## Frequently Asked Questions

**What is a native app?**
A native app is written in the platform's own language, Swift or Objective-C for iOS and Kotlin or Java for Android, and compiled into a binary that runs directly on the device using the platform's own interface frameworks. It is distinct from a web app, which runs in a browser, and from a wrapper, which is a website displayed inside an app shell.

**What is the best native app maker in 2026?**
It depends on what you need to keep. For native Swift source you can export and own, Superapp is the only tool in that tier, from $25 a month, Apple platforms only. For iOS and Android from one visual project with code export, FlutterFlow at $39 a month or Draftbit at $12 a month. For developers, Expo with React Native is free and open source.

**Is React Native actually native?**
Partly, and React Native is precise about which part. Its own documentation says apps are "written in JavaScript, rendered with native code," and that at runtime it "creates the corresponding Android and iOS views." So the interface uses real platform views and real platform APIs, but your logic stays JavaScript. It is not compiled into Swift or Kotlin.

**Can you build a native app without knowing how to code?**
Yes. Tools like Superapp, FlutterFlow, Adalo, Bubble and Thunkable all produce App Store binaries without you writing code. What varies enormously is whether you can export the resulting source, and whether the app keeps working if you stop paying.

**What is the difference between a native app and a web app?**
A native app is installed from an app store and runs compiled code on the device with full access to platform APIs. A web app runs in a browser, needs no store approval, and is limited to what the browser exposes. A progressive web app sits in between, adding offline support and an install prompt, but it still cannot be listed in the App Store.

**What is the difference between native and hybrid apps?**
A native app's interface is built with the platform's own frameworks. A hybrid app runs your HTML, CSS and JavaScript inside a native container such as Capacitor, which Capacitor itself describes as "a cross-platform native runtime for web apps." Hybrid is faster to build from an existing web codebase, but it carries more App Store review risk when the app is thin.

**What are some examples of native apps?**
Apple's own apps, Messages, Maps, Photos and Safari, are native by definition. Beyond those you usually cannot tell from the outside, because well-built React Native and Flutter apps are indistinguishable to users. React Native's documentation names Discord, Shopify and Instagram as apps built with it.

**Does a native app perform better than a cross-platform one?**
Usually, and the gap shows up in long lists, heavy screens and cold start rather than in simple apps. Every layer between your code and the operating system costs something: native has none, compiled cross-platform has a thin one, a vendor runtime has one you do not control, and a WebView has a whole browser engine. For a twelve-screen app most users will not notice.

**Do I need a Mac to build a native iOS app?**
Not any more, though Apple's own toolchain still requires one. Xcode runs only on macOS. Browser-based tools including Superapp, FlutterFlow and Draftbit build and submit from the cloud, so a Mac is optional. You still need an Apple Developer Program membership at $99 a year.

**Can Glide publish to the App Store?**
No. Glide's own help centre states that it "is built using Progressive Web App (PWA) technology, which means its apps cannot be published in traditional app stores like Google Play or Apple App Store," and separately that "Glide does not offer any native app publishing options." Third-party wrapping tools exist, but Glide says it "does not endorse or support this practice."

**Is Adalo really native?**
Adalo compiles a real IPA and AAB, so it produces genuine store binaries rather than a PWA. But its marketing claim of "real native builds... not a React Native wrapper" conflicts with its own developer documentation, which states "our mobile builds use React Native." Both statements are published by Adalo, on adalo.com and developers.adalo.com respectively.

**Does Bubble build native mobile apps?**
Bubble publishes real apps to both stores, built on React Native. In Bubble's words, "Bubble uses React Native, a JavaScript framework, to create cross-platform mobile apps that work for iOS and Android out of the box." Native mobile entered public beta in June 2025 and moved to paid plans on 1 October 2025. A paid plan is required to deploy a live version.

**What happens to my app if I stop paying for the app maker?**
It varies more than most people expect. Thunkable states that "if your subscription expires, any published apps will become unavailable for your end users." Bubble warned that mobile apps not moved to a paid plan would downgrade to Free and that "existing live versions will no longer be supported." Tools that let you export the source, including Superapp, FlutterFlow, Draftbit and Newly, leave you with something you can keep maintaining.

**Can I export the source code from a no-code app maker?**
From some, on some plans. FlutterFlow allows code download from Basic at $39 a month and not on Free. Draftbit allows export from Standard at $12 a month, with GitHub export only from Pro at $24. Newly exports to ZIP or GitHub. Superapp exports Swift. Bubble, Adalo and Thunkable document no source export at all.

**Can I move my app from one builder to another?**
Only if you can export. From a tool that exports Swift, Flutter or React Native, migration is a normal engineering task and your App Store listing and reviews survive because you ship a new build of the same app. From Bubble, Adalo or Thunkable there is no migration, only a rebuild from scratch while the original keeps running and keeps costing.

**Will Apple reject an app that is just my website in a wrapper?**
Very possibly. Apple's guideline 4.2 requires an app to "include features, content, and UI that elevate it beyond a repackaged website," and 4.2.2 says apps "shouldn't primarily be marketing materials, advertisements, web clippings, content aggregators, or a collection of links." Median, which sells WebView apps, tells its own readers that a wrapper "with nothing native added" should "expect a Guideline 4.2 or 2.1 rejection."

**How many apps does Apple reject?**
In 2025, Apple reviewed 9,100,620 app submissions and rejected 2,093,244 of them, according to its own App Store Transparency Report. The Design category accounted for 415,532 rejections, and Apple's footnote explains that this category "includes guidelines that prohibit copycat apps, apps with minimum functionality, and spam."

**What does Apple guideline 4.2 say?**
Guideline 4.2, Minimum Functionality, opens: "Your app should include features, content, and UI that elevate it beyond a repackaged website. If your app is not particularly useful, unique, or 'app-like,' it doesn't belong on the App Store." Related clauses cover web clippings (4.2.2) and thin clients for cloud-based apps (4.2.7e).

**What is guideline 4.2.6 and does it affect app builders?**
Yes, directly. It says "apps created from a commercialized template or app generation service will be rejected unless they are submitted directly by the provider of the app's content," and that such services "should not submit apps on behalf of their clients." If a builder offers to submit for you, this is the clause to understand before accepting.

**What is the safest option for getting through App Store review?**
Tier 1 and Tier 2 tools, because their output is an ordinary app to a reviewer. Wrappers carry the most exposure, since guideline 4.2 was written about them. Whatever you use, submit from your own developer account to stay clear of 4.2.6, and give the reviewer working login credentials, because a locked-out reviewer is one of the most common rejections and has nothing to do with your tool.

**How much does it cost to publish an app to the App Store?**
The Apple Developer Program is $99 a year and is required regardless of which tool you use. Google Play charges a $25 one-time registration fee. On top of that you pay whichever builder tier first unlocks publishing, which ranges from free with Expo's EAS to $59 a month with Bubble.

**What is the cheapest native app maker?**
Excluding free open-source frameworks, Draftbit at $12 a month is the cheapest tool here that both publishes to the App Store and lets you export your source. Expo with React Native is free outright if you can write TypeScript, and EAS has a free build tier that submits to the stores. Over three years, including Apple's $99 a year, Draftbit works out around $729 against Bubble's $2,421.

**Is Thunkable native?**
Thunkable describes its output as native and publishes real apps to both stores. However, it does not document what its apps are actually built with, and it documents no way to export your source code. It also states that published apps become unavailable to your users if your subscription lapses.

**What is the difference between Natively and BuildNatively?**
They are different products. natively.dev now redirects to newly.app, a React Native and Expo builder with full code export, from $25 a month. BuildNatively at buildnatively.com is a separate WebView product that, in its own description, "works by securely wrapping your website inside a mobile app using WebView technology." One produces a codebase, the other wraps a website. They even have separate Trustpilot profiles with very different scores.

**Why do Trustpilot and G2 scores differ so much for these tools?**
Because they measure different things. G2 and Capterra reviews are largely recruited and assess whether the product does its job. Trustpilot is where people go when something went wrong, so samples are small and skew toward support complaints. Ten of FlutterFlow's 22 Trustpilot reviews are about support response rather than the product, and several of those reviewers praise the product in the same breath.

**What are AI credits and why do they run out so fast?**
A credit is one unit of AI work, usually one prompt or agent request, and it is consumed whether or not the result was useful. That is the structural problem: a failed fix costs the same as a successful one. Five of Draftbit's eleven G2 reviews and two of Newly's three Trustpilot reviews raise credit cost or unpredictability, so budget for iteration rather than for the first generation.

**Does Superapp build Android apps?**
No. Superapp is Apple platforms only, covering iPhone, iPad and Mac. If you need Android from the same project, FlutterFlow, Draftbit, Newly and Expo with React Native all do that, and this article ranks them in Tier 2 for exactly that reason.

## References

- Apple, App Store Review Guidelines: [https://developer.apple.com/app-store/review/guidelines/](https://developer.apple.com/app-store/review/guidelines/)
 - Apple, App Store Transparency Report 2025: [https://www.apple.com/legal/app-store/transparency/2025/](https://www.apple.com/legal/app-store/transparency/2025/)
 - Apple Newsroom, App Store fraud prevention 2025: [https://www.apple.com/newsroom/2026/05/the-app-store-stopped-over-2-point-2-billion-usd-in-fraudulent-transactions-in-2025/](https://www.apple.com/newsroom/2026/05/the-app-store-stopped-over-2-point-2-billion-usd-in-fraudulent-transactions-in-2025/)
 - Apple, Technology Overviews, app design and UI: [https://developer.apple.com/documentation/TechnologyOverviews/app-design-and-ui.md](https://developer.apple.com/documentation/TechnologyOverviews/app-design-and-ui.md)
 - Apple, Swift: [https://developer.apple.com/swift/](https://developer.apple.com/swift/)
 - Apple, Xcode: [https://developer.apple.com/xcode/](https://developer.apple.com/xcode/)
 - React Native: [https://reactnative.dev/](https://reactnative.dev/)
 - React Native, core components: [https://reactnative.dev/docs/intro-react-native-components](https://reactnative.dev/docs/intro-react-native-components)
 - Expo pricing: [https://expo.dev/pricing](https://expo.dev/pricing)
 - FlutterFlow pricing: [https://www.flutterflow.io/pricing](https://www.flutterflow.io/pricing)
 - FlutterFlow reviews, Trustpilot: [https://www.trustpilot.com/review/flutterflow.io](https://www.trustpilot.com/review/flutterflow.io)
 - FlutterFlow reviews, G2: [https://www.g2.com/products/flutterflow/reviews](https://www.g2.com/products/flutterflow/reviews)
 - Draftbit FAQ: [https://draftbit.com/faq/](https://draftbit.com/faq/)
 - Draftbit pricing: [https://draftbit.com/pricing](https://draftbit.com/pricing)
 - Draftbit reviews, G2: [https://www.g2.com/products/draftbit/reviews](https://www.g2.com/products/draftbit/reviews)
 - Newly FAQ: [https://newly.app/faq](https://newly.app/faq)
 - Newly about: [https://newly.app/about](https://newly.app/about)
 - Natively documentation: [https://docs.natively.dev/](https://docs.natively.dev/)
 - Natively reviews, Trustpilot: [https://www.trustpilot.com/review/natively.dev](https://www.trustpilot.com/review/natively.dev)
 - Bubble, native mobile beta: [https://bubble.io/blog/native-mobile-beta/](https://bubble.io/blog/native-mobile-beta/)
 - Bubble, native mobile pricing: [https://bubble.io/blog/native-mobile-pricing-2025/](https://bubble.io/blog/native-mobile-pricing-2025/)
 - Bubble reviews, Capterra: [https://www.capterra.com/p/171359/Bubble/reviews/](https://www.capterra.com/p/171359/Bubble/reviews/)
 - Adalo, App Store publishing: [https://www.adalo.com/products/app-store-publishing/](https://www.adalo.com/products/app-store-publishing/)
 - Adalo developer docs, cross-platform: [https://developers.adalo.com/docs/workflow/cross-platform/](https://developers.adalo.com/docs/workflow/cross-platform/)
 - Adalo reviews, Capterra: [https://www.capterra.com/p/207495/Adalo/reviews/](https://www.capterra.com/p/207495/Adalo/reviews/)
 - Thunkable documentation: [https://docs.thunkable.com/](https://docs.thunkable.com/)
 - Thunkable reviews, G2: [https://www.g2.com/products/thunkable/reviews](https://www.g2.com/products/thunkable/reviews)
 - Glide, publishing to an app store: [https://help.glideapps.com/en/articles/9247733-publishing-glide-apps-to-an-app-store](https://help.glideapps.com/en/articles/9247733-publishing-glide-apps-to-an-app-store)
 - Glide reviews, G2: [https://www.g2.com/products/glide-2023-07-10/reviews](https://www.g2.com/products/glide-2023-07-10/reviews)
 - Median, appealing an App Store rejection: [https://median.co/blog/how-to-appeal-to-app-store-review-after-app-store-rejection](https://median.co/blog/how-to-appeal-to-app-store-review-after-app-store-rejection)
 - BuildNatively reviews, Trustpilot: [https://www.trustpilot.com/review/buildnatively.com](https://www.trustpilot.com/review/buildnatively.com)
 - Capacitor documentation: [https://capacitorjs.com/docs](https://capacitorjs.com/docs)

Related reading on this site: [the best AI app builder for native iOS apps](https://superapp.dev/blog/the-best-ai-app-builder-for-native-ios-apps-2026), [best no-code platforms for making iPhone apps](https://superapp.dev/blog/best-no-code-platforms-for-making-iphone-apps-2026), [can a non-technical founder build a native Apple app](https://superapp.dev/blog/can-a-non-technical-founder-build-a-native-apple-app), [best app builders for iPad apps](https://superapp.dev/blog/best-app-builders-for-ipad-apps-2026), [FlutterFlow alternatives](https://superapp.dev/blog/best-flutterflow-alternatives-in-2026-free-native-options), and [native Swift vs React Native and Expo](https://superapp.dev/blog/native-swift-vs-react-native-expo-in-2025-2026).

## Keep reading

[Best App Makers for Business in 2026: 14 Ranked

Sep 18, 2026](https://superapp.dev/blog/best-app-makers-for-business) [Best AI Web App Makers in 2026: 11 Tools Compared

Sep 18, 2026](https://superapp.dev/blog/best-ai-web-app-makers) [How to Make an App on Your Phone in 2026 (No Mac, No Computer)

Sep 17, 2026](https://superapp.dev/blog/how-to-make-an-app-on-your-phone)

## Build iOS apps with AI

Turn your ideas into production-ready iOS apps. Fast and easy.

[Get started](https://superapp.dev/)