Every iOS app gets built on a Mac. Developers write native apps for iPhone and iPad in Swift (or Objective-C, if the project is old), compile them in Xcode and ship them through the App Store.
Apple also decides which toolchain version you’re allowed to ship with. Since April 28, 2026, App Store Connect accepts uploads only when they are built with Xcode 26 or later and an SDK for iOS 26 or another version 26 platform (Apple Developer, 2026).
For any app that gets updates, that turns every Xcode upgrade into a dated maintenance task.
What Is iOS Development?
The end product is a signed app that users install from the App Store or from a TestFlight beta. iPhone apps are the target, and iPad versions come out of the same Xcode project.
Code is written in Swift or Objective-C and compiled in Xcode against Apple’s SDK. Distribution runs through the App Store and TestFlight.
It sits inside the wider field of building mobile applications, but with its own toolchain and its own distribution rules.
According to StatCounter Global Stats, iOS held 30.81% of worldwide mobile OS use in September 2026, against 69.17% for Android. Developing for Android follows a separate path with its own language and tooling.
The other gap is hardware. iOS runs only on Apple hardware, and Xcode runs only on a Mac.
It isn’t web development, and it isn’t cross-platform tooling either, although both can end with an iOS build.
What You Need Before Writing Any iOS Code
Xcode and a free Apple Account on a Mac are enough to start building and to test on your own iPhone. A paid Apple Developer Program membership only matters once you distribute an app.
The Mac comes first, because Xcode runs only on macOS. Xcode 27 asks for macOS Tahoe 26.6 or later (Apple, Xcode system requirements) and installs only on Apple silicon Macs, according to Apple’s Xcode 27 release notes.
That second condition has a clock on it. Apple requires the iOS 27 SDK for App Store uploads from April 2027 (announced September 2026), and an Intel Mac stops at Xcode 26, so it can ship updates only until then.
The free Apple Account covers Xcode, documentation, sample code and on-device testing. Money comes in at distribution. The Apple Developer Program costs 99 USD per membership year and unlocks app distribution, App Store Connect and advanced app capabilities.
Companies that want to hand apps to their own employees, without going through the store, can look at the Enterprise Program at 299 USD per year. It covers private distribution through an internal system or device management.
Prices appear in local currency during enrollment. Nonprofits, accredited schools and government entities can apply for a fee waiver (Apple Developer).
A free account has tight limits. Apple’s Personal Team setup caps test devices at 3 per platform, and provisioning profiles expire after 7 days, which forces a rebuild and reinstall.
Individuals sign up with an Apple Account that has two-factor authentication turned on, and they need to use their legal name and be of legal age of majority in their region.
Organizations also need a D-U-N-S Number, which Dun & Bradstreet issues for free. The App Store listing then shows the organization’s legal entity name instead of a personal one.
When a Windows or Linux Machine Is Not Enough
Windows tools can edit Swift files. Compiling and signing happen in Xcode, though, and so does the simulator, and Xcode has no Windows or Linux version.
That leaves renting a Mac in the cloud or buying one. Setups that run macOS in a virtual machine on non-Apple hardware fall outside Apple’s license terms.
Which Programming Language Does iOS Development Use?
Swift, for nearly everything new. SwiftUI and SwiftData are Swift-only APIs, and Objective-C mostly sticks around to maintain older apps.
Apple released Swift 6.4 on September 15, 2026 (Swift.org announcement), and Xcode 27 ships it as its compiler.
Xcode picks the compiler version for you. Xcode 27 carries Swift 6.4 and Xcode 26.6 carries Swift 6.3, so moving a project to a newer Swift means upgrading Xcode.
Per Apple’s WWDC26 Swift guide, the 6.4 changes app developers notice first include async calls inside defer blocks, which let cleanup code await. The anyAppleOS syntax gives a shorter way to write availability checks across Apple platforms. There’s also the @diagnose attribute, for finer control over compiler warnings.
Objective-C is the older language and still compiles in Xcode. Swift and Objective-C files can live in one project, which lets a team migrate an older app piece by piece, and how Swift compares with Objective-C matters mainly when you inherit such a project.
New developers can start without Xcode. Swift Playground, Apple’s free learning app for iPad and Mac, runs real Swift code and moves projects into Xcode when they outgrow it. Keep a Swift cheat sheet open for syntax while you practice.
Xcode and the iOS SDK Toolchain
Xcode is Apple’s integrated development environment. It builds against the iOS SDK, the bundle of frameworks and tools, and the SDK’s application layer is called Cocoa Touch, with UIKit sitting inside it.
Apple’s compatibility table splits Xcode 27’s reach into two ranges as of October 2026. Apps can target iOS 15 through 27, but the simulator and on-device debugging start at iOS 17.
Xcode 26.6 still debugs and simulates iOS 15 and up. A team that supports iOS 15 or 16 users on Xcode 27 builds for them without being able to run them locally.
What Xcode Includes
| Component | What it does | When you use it |
|---|---|---|
| Code editor | Writes Swift and Objective-C with completion and previews | Every working session |
| Interface Builder | Lays out screens visually with storyboards and Auto Layout constraints | UIKit screens |
| iOS Simulator | Runs the app on virtual iPhone and iPad models on the Mac | Quick checks without a device |
| Instruments | Profiles CPU, memory and energy use | Chasing slow screens and leaks |
Camera and motion sensors need a physical iPhone to test properly.
Frameworks Behind Common App Features
Core Data is the older local-storage framework. SwiftData, available from iOS 17, builds on Core Data’s persistence technology with a Swift-native API (Apple Developer Documentation).
StoreKit handles purchases and subscriptions inside the app, and Apple Push Notification service delivers remote notifications from your server to the device.
Because SwiftData starts at iOS 17, apps that still support iOS 15 or 16 cannot call it without availability checks.
Dependency Managers and Test Frameworks
The CocoaPods blog sets December 2, 2026 as the date CocoaPods trunk goes read-only, after a test run from November 1 to 7. Existing builds keep working, but pods hosted on trunk stop receiving new versions.
Qonversion’s migration guide describes it plainly. New SDK releases stop reaching trunk, and Swift Package Manager becomes the supported route.
Swift Package Manager is Apple’s own tool. Since Swift 6.4 it uses Swift Build by default, so packages build the same way on macOS, Linux and Windows (Swift.org announcement), and new projects should start there.
On the testing side, XCTest is Apple’s long-standing framework and Swift Testing is the newer library. Swift 6.4 adds interoperability between the two, so teams can move existing unit testing suites over a file at a time (Apple’s WWDC26 Swift guide).
SwiftUI vs UIKit: Choosing a UI Framework for a New App
SwiftUI is the default for a new app. UIKit stays for mature codebases and for screens that need fine control, and the two frameworks interoperate in one project.
| Attribute | SwiftUI | UIKit |
|---|---|---|
| Programming style | Declarative: describe the interface for a given state | Imperative: build views, then update them step by step |
| Updating the screen | Observed state triggers redraws | Code changes views and view controllers directly |
| Mixing the two | UIViewRepresentable and UIViewControllerRepresentable host UIKit views and controllers | UIHostingController hosts SwiftUI views |
| Best fit | New apps and new screens | Mature apps and complex custom screens |
SwiftUI starts at iOS 13, which is also the lowest version App Store Connect accepts for uploads since September 9, 2026 (Apple Developer). UIKit’s old edge, reach to older iOS releases, no longer applies to apps built with current Xcode, because the toolchain’s own deployment floor, covered earlier, sits higher still.
Each new SwiftUI API carries its own minimum iOS version in Apple’s documentation. A feature that works in a demo can need availability checks in an app that supports older releases.
AllTrails shows how teams split the work. Its CTO told Apple’s Meet with Apple audience in February 2026 that UIKit still handles the app lifecycle, navigation and complex surfaces such as the trail page, while new features and design system components are built in SwiftUI.
Neither choice changes how an app should look. Both frameworks follow the same rules in Apple’s interface design guidelines.
How App Architecture Fits In
UIKit apps are organized around view controllers, with Model-View-Controller as the traditional pattern. Lifecycle callbacks arrive through the app delegate and scene delegate.
SwiftUI works differently. Views describe the interface as a function of state, and the App protocol declares the entry point and scenes. A model type marked with the @Observable macro drives view updates, which is the shape MVVM takes in SwiftUI, and the Observation framework behind that macro starts at iOS 17, the same floor as SwiftData (Apple Documentation).
Hybrid apps run both models side by side, so the trade-offs between MVC and MVVM show up inside a single codebase.
How to Take an iOS App From Xcode to the App Store
A finished build reaches a public release by way of signing, upload, TestFlight, store details, App Review and release. Steps three to five repeat on every update, and they make up most of routine app deployment.
- Register a bundle identifier and create the app record in App Store Connect.
- Let Xcode manage code signing, which creates the certificate and provisioning profile for the app.
- Set the version number, build number and deployment target, the lowest iOS version the app supports.
- Archive the app in Xcode and upload the build to App Store Connect.
- Test the build in TestFlight with internal testers, then with external testers if needed.
- Complete the store listing: description, screenshots, privacy details and the age rating questions.
- Submit the build for App Review.
- Release manually, on a schedule or automatically once App Review approves.
TestFlight accepts up to 10,000 external testers. The first build for that group needs approval from App Review for TestFlight, and builds go to review as soon as they join a group (Apple Developer).
Apple asked developers to answer the updated age rating questions by January 31, 2026 to avoid an interruption when submitting app updates.
Since April 28, 2026, App Store Connect requires uploads built with Xcode 26 or later and an SDK for iOS 26 or another version 26 platform. Xcode 15 held that role from April 29, 2024.
Building with a newer SDK does not raise the deployment target. The two are separate columns in the compatibility table covered earlier.
Signing and provisioning errors show up at archive or upload time, before App Review gets involved. Rejections are a different kind of failure, and Apple’s App Review Help gives a handful of guideline areas their own explainer pages.
Screenshots (2.3.3) should show the app in use. Copycat apps (4.1) is about not impersonating another app or developer. For purpose strings (5.1.1(ii)), write a clear reason for each permission prompt, and under account deletion (5.1.1(v)) the app has to offer deletion from inside it.
The Notes field in App Review Information is where reviewers get context such as demo credentials and supporting documents.
How Long Does App Review Take?
Most submissions clear within a day or two, but Apple publishes a goal rather than a guarantee, and a slow tail exists.
Apple’s goal is at least 50% of submissions reviewed in under 24 hours and 90% in under 48 hours (Apple App Review Help). Runway’s tracker (updated October 20) shows Waiting for Review averaging 13h 2m in October 2026, and In Review averaging 1h 32m in the same month.
Waiting for Review is just queue time. The reviewer’s actual work happens in In Review, so that number stays small.
The sources disagree on the headline figure. Apple’s current help page puts the 90% mark at 48 hours, while replies on the Apple Developer Forums and many third-party guides still repeat the older 90% in 24 hours.
Developers also report waits of several days to a couple of weeks. One June 2026 forum thread describes a new app that stayed in Waiting for Review after Developer Support escalated it.
Part of the spread comes down to method. A 90% goal says nothing about the slowest tenth. Runway reports a truncated mean that trims extreme waits, and its sample only covers teams that use its product.
Apple points to documentation checks as one reason a review runs long, when App Review must verify authorizations, licenses or partnership agreements. Complex or novel issues, such as regulated content, new platform capabilities or entitlements, can slow things down too.
Attach required documents in App Review Information before submitting, as Apple advises. And when App Review only asks for information, reply in App Store Connect, because resubmitting starts a new review.
Critical bug fixes and event-tied releases can request an expedited review, a route Apple documents in App Review Help. Runway’s day-of-week breakdown shows Wednesday submissions waiting least and Sundays most.
External TestFlight builds wait in a separate beta queue, which Runway currently shows running longer than the store queue.
Native iOS Development vs Cross-Platform Frameworks
Native Swift suits iOS-first apps and anything that leans hard on Apple’s frameworks. Teams that want the cross-platform route to iOS and Android from a single codebase usually look at React Native or Flutter.
| Attribute | Native iOS | React Native | Flutter |
|---|---|---|---|
| Language | Swift | JavaScript or TypeScript | Dart |
| UI rendering | UIKit and SwiftUI | Maps to native iOS components | Draws its own widgets |
| New iOS APIs | Direct access | Native module | Plugin or native code |
| Build tooling | Xcode | Xcode for the iOS build | Xcode for the iOS build |
| Best fit | iOS-first, platform-heavy apps | Teams with React skills | Identical custom UI on both platforms |
Flutter and React Native are the clear cross-platform leaders, and most apps still ship fully native (The Pragmatic Engineer). Which of the two leads depends on where you look. React Native powers more iOS apps and Flutter more Android apps, and Germany and India lean Flutter while the US and UK lean React Native.
Choosing between the two is a separate decision, and this look at how Flutter stacks up against React Native covers it.
When Native iOS Development Is the Wrong Fit
Native fits poorly when one small team has to ship iOS and Android together, or when its engineers know React better than Swift. React’s popularity also makes that skill easier to hire for than native iOS or Android developers, according to The Pragmatic Engineer.
Shopify went all-in on React Native in 2020 to build features once, let developers without mobile experience contribute and stop chasing parity between platforms (Shopify Engineering).
On September 10, 2026 it announced a move back to Swift and Kotlin, and the Shop app reached the stores as a native rebuild in 12 weeks. Shopify credits coding agents for lowering the cost of two native codebases, while noting that native still means maintaining software on two platforms.
One company’s reversal is a data point on cost, not a verdict on cross-platform tools.
One limit stays no matter which route you pick. Flutter’s setup guide lists Xcode as the way to compile for iOS, so a Mac, owned or rented, remains in the pipeline. The same guide still asks for CocoaPods when plugins use native iOS code, the dependency manager whose trunk change was covered earlier.
iOS Development FAQ
Is iOS development the same as macOS or watchOS development?
No. Each Apple platform has its own SDK, simulator and submission requirements, even though Xcode, Swift and SwiftUI carry across.
Xcode 27 ships separate SDKs for iOS, iPadOS, tvOS, watchOS, macOS and visionOS (Apple, Xcode system requirements).
Can Swift be used outside iOS?
Yes. Swift 6.4 ships a WebAssembly SDK through Swift.org, adds existential types and richer error handling to Embedded Swift for microcontroller-class targets, and improves interoperability with C++, Java and C.
Command-line tools use its Subprocess library, now at version 1.0.
Which minimum iOS version should an app support?
Pick the oldest version your own analytics show real users on, within the limits the toolchain sets.
Apple’s App Review Help has a page on how device compatibility affects distribution and when restricting availability makes sense.
How does the Apple Developer Enterprise Program differ from the standard membership?
Eligibility decides it. The Enterprise Program is for organizations that need private distribution directly to employees through a secure internal system or device management, and Apple sets the eligibility requirements.
Apps meant for the public go through the standard program and the App Store.
Why do iOS apps get rejected?
Rejections follow guideline violations. Apple’s help names misrepresented developer identity, manipulation of the App Store experience and low-quality apps flagged by heavy customer reports as conduct it investigates.
A rejected submission shows Unresolved Issues in App Store Connect. Fix every flagged issue before resubmitting, because resubmitting with open issues delays review and ends the same way.
How long does it take to learn iOS development?
There is no single figure, because the time depends on prior programming experience.
A first screen in Swift Playground needs no coding background, but a shipped app also needs signing, TestFlight testing and App Review, so plan for the whole path.
What does an iOS developer do?
The job covers designing, building, testing and releasing apps for Apple’s mobile platform.
The core skills are Swift, Xcode and SwiftUI or UIKit, plus connecting apps to cloud services through APIs, testing and the App Store release path.
Shipping a First iOS App and Keeping It Live
A small first release works best. Think a SwiftUI app with two or three screens, no sign-in and no payments. That scope exercises signing, TestFlight and App Review with the fewest points of failure.
Start with an internal TestFlight build for the team, then move to an external TestFlight build with its beta review, and submit to the App Store last. Each step exposes signing, permission and metadata problems before the next one adds its own review.
Upkeep follows Apple’s SDK calendar, and the dated minimum Xcode deadlines Apple lists (April 25, 2023, April 29, 2024 and April 28, 2026) all fall in the last week of April. Apple has named only the month, April 2027, for the iOS 27 SDK minimum.
Planning a rebuild and retest before that month ends costs one Xcode upgrade per new minimum, even for an app with no new features. As of October 21, 2026, Apple lists no Xcode deadline outside April, and one would change this schedule.
- SQLite cheat sheet - October 29, 2026
- Shared Hosting or VPS? A Practical Guide for Web Projects in 2026 - October 29, 2026
- Best Procore Alternatives: A Side-by-Side Comparison of Cost, Data Sharing and AI - October 28, 2026
