A step-by-step guide to creating, running, and iterating on your first SwiftUI app in Swift Playgrounds on iPad, using real Swift you can later open in Xcode.
In this guide you will create a small but real SwiftUI app project in Swift Playgrounds on iPad and run it live.
The goal is to get from a blank app to a screen with your own interactive content, using genuine Swift and SwiftUI the whole way.
You need an iPad capable of running a current version of Swift Playgrounds, the free app from the App Store, and a little patience for the first run.
A keyboard helps but is not required. Swift Playgrounds is designed to be usable with touch, on-screen suggestions, and code completion.
Download Swift Playgrounds from the App Store on your iPad. It is free.
Open it, and you will land on a screen showing your existing projects and the learning content Apple provides.
If this is your very first time, consider skimming one of the introductory lessons. It is optional, but it familiarizes you with the editor and how running code feels.
When you are ready to build, look for the option to create a new project. Swift Playgrounds distinguishes between playground-style files and full app projects, and for building an iOS app you want the app option.
Choose to create a new app. Swift Playgrounds scaffolds a starter SwiftUI app for you.
This starter already compiles and runs. That is intentional: you always begin from something that works, then change it.
Give your app a clear name. You can rename the project from the app's project organization view, and a tidy name pays off later when you have several projects.
Take a moment to look at the generated structure. You will see a main view written in SwiftUI, which is where your screen is described in code.
The starter app centers on a SwiftUI view, typically a struct that conforms to the View protocol and defines a body property.
The body describes what appears on screen. A common starting point is a Text view inside a VStack, which stacks elements vertically.
SwiftUI is declarative. You describe what the UI should look like for a given state, and the framework renders it, rather than you manually mutating views.
Read the code slowly once. Identifying which lines draw which on-screen elements is the single most useful skill for everything that follows.
Run the app using the run control in Swift Playgrounds. The app launches in a live preview right alongside your code.
This tight loop is the heart of the experience. You change code, run, and immediately see the result.
If the app does not run, read the error message it surfaces. Most first-run errors are small typos, such as a missing bracket or a misspelled view name.
Once it runs, you have a genuine SwiftUI app executing on your iPad. Everything from here is iteration.
Start by editing the text. Change the Text content to your own words and run again to confirm the loop works for you.
Next, add an element. Try adding a Button inside the VStack, with a label and an action closure that changes a value.
To make the button do something visible, introduce state. Declare a property with the @State attribute, and update it inside the button's action so the view re-renders.
For example, keep a counter in @State, show it in a Text view, and increment it in the button action. When you run, tapping the button updates the number live. That single pattern, state plus a control that mutates it, underlies a huge portion of real SwiftUI apps.
Swift Playgrounds saves your project automatically as you work, but it is worth understanding where projects live.
From the main screen you can see, rename, and manage your projects. Keep names descriptive so future-you can find them.
As your app grows, split your code into multiple SwiftUI views and files. Smaller, focused views are easier to reason about than one giant body.
Good organization early makes the later jump to Xcode painless, because the project structure carries over cleanly.
Once a single screen feels comfortable, the natural next step is a second view, because real apps are never just one screen.
Create a new struct that conforms to View, give it its own body, and put some content inside, such as a Text and an image.
Then show it from your main view. Wrapping your content in a NavigationStack and adding a NavigationLink lets a tap push to your new screen with a back button handled for you.
This is the moment your project starts to feel like an app rather than a demo. Two screens and a tap to move between them is the seed of almost every iOS app you have ever used.
A few snags trip up nearly everyone on their first build, so it helps to know them in advance.
The most common is a mismatched bracket or brace. Because SwiftUI nests views deeply, a single missing closing brace can produce a confusing error far from the real spot. Lean on code completion and indentation to keep things balanced.
Another is forgetting that the body must return a view. If you drop a plain statement like a print or a loop directly into the body, the build will complain. Compute values before the view content instead.
A third is editing a value without storing it in state. If a number does not update on screen when you change it, it likely needs the @State attribute so SwiftUI knows to re-render. None of these are serious; they are just the rite of passage every SwiftUI beginner goes through.
Once you are comfortable, deepen your SwiftUI vocabulary. Learn lists, navigation, images, and how to pass data between views.
Apple's own lessons inside the app and the official SwiftUI documentation are excellent next steps, and they use the same concepts you just practiced.
When your app gets ambitious enough to need advanced build settings or heavy dependencies, remember the project opens in Xcode on a Mac. Swift Playgrounds is a launchpad, not a cage.
Keep your loop tight: small change, run, observe. That habit is how real iOS apps get built, and you already have it.
No. You can build and run a SwiftUI app entirely on iPad. A Mac is only needed if you later want Xcode's advanced tooling.
Yes. Swift Playgrounds uses genuine Swift and SwiftUI, so what you learn transfers directly to professional iOS development.
@State is a property wrapper that stores changeable values in a view. When the value changes, SwiftUI re-renders the view to reflect it.
Yes. App projects are compatible with Xcode, so you can continue a project on a Mac when it grows beyond Swift Playgrounds.
Read the error Swift Playgrounds shows. Most first-run failures are small typos like a missing bracket or a misspelled view name.