RizTech Academy logo
RizTech Academy

Swift and iOS Development

Build and ship native iPhone apps with Swift and SwiftUI — from your first line to the App Store.

This course teaches the Swift language from scratch and then uses it to build real iPhone apps with SwiftUI, finishing with an app submitted to the App Store.

SwiftUI comes first throughout. UIKit gets one module, because every existing codebase you join will contain it and you need to recognise it — but new work is written in SwiftUI and that is where the time goes.

Be aware of one hard requirement before you start: iOS development needs a Mac. Xcode does not run on Windows or Linux, and there is no honest workaround. If you do not have access to one, the Kotlin Multiplatform course on this site builds for iPhone from any machine for most of its length, and is the better place to start.

You finish able to design, build, test and ship a native iOS app on your own.

Who this is for

  • Developers who want to build for iPhone and iPad specifically
  • Android developers adding a second platform
  • Anyone with a Mac and an idea they want on the App Store
  • Interns joining mobile client work

What you need first

  • A Mac running a recent macOS. This is not negotiable — Xcode runs nowhere else.
  • No Swift needed. The first four modules teach the language from nothing.
  • Some prior programming in any language will make the early modules much faster.
  • An Apple Developer account is only required for the final module, and costs money.

Tools you will use

XcodeSwift 6SwiftUISwiftDataInstrumentsTestFlight

By the end you can

  • Write idiomatic Swift, including optionals, protocols and value types
  • Build interfaces declaratively with SwiftUI
  • Manage state correctly instead of fighting the framework
  • Navigate between screens and pass data cleanly
  • Call APIs and handle failure without freezing the interface
  • Store data on device with SwiftData
  • Use async/await without blocking the main thread
  • Test and debug an app with Xcode's own tools
  • Submit an app to the App Store and survive review
Syllabus

14 modules, 70 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Getting Started

    Xcode, a running app on a simulator, and an honest look at what iOS development requires.

    1. What iOS development actually involvesComing soon
    2. Installing Xcode, and what it gives youComing soon
    3. Your first app on the simulatorComing soon
    4. Finding your way around XcodeComing soon
    5. Playgrounds: the fastest way to try SwiftComing soon
  2. 2

    Swift Basics

    The language, from variables to control flow.

    1. var, let, and why let comes firstComing soon
    2. Types, inference and annotationsComing soon
    3. Strings and interpolationComing soon
    4. if, guard, switch and loopsComing soon
    5. switch, and pattern matching worth the nameComing soon
  3. 3

    Collections and Optionals

    Arrays, dictionaries, and the feature that defines Swift.

    1. Arrays and setsComing soon
    2. DictionariesComing soon
    3. Optionals: the whole point of SwiftComing soon
    4. Unwrapping safely, and why you should never force itComing soon
    5. map, filter and reduceComing soon
  4. 4

    Functions, Structs and Protocols

    How Swift code is actually organised, and why structs come before classes.

    1. Functions, argument labels and defaultsComing soon
    2. Closures, and reading the syntax without fearComing soon
    3. Structs versus classes: value and referenceComing soon
    4. Protocols, and protocol-oriented designComing soon
    5. Extensions and genericsComing soon
    6. Errors: throws, try and ResultComing soon
  5. 5

    SwiftUI Fundamentals

    Describing an interface rather than assembling one.

    1. Declarative UI, and why it is differentComing soon
    2. Views and modifiersComing soon
    3. Stacks: VStack, HStack and ZStackComing soon
    4. Text, images and shapesComing soon
    5. Previews, and the fastest way to iterateComing soon
  6. 6

    Layout and Styling

    Making it look right on every device, including the small ones.

    1. How SwiftUI decides where things goComing soon
    2. Frames, padding and spacersComing soon
    3. Adapting to screen sizes and orientationComing soon
    4. Colour, dark mode and the system paletteComing soon
    5. Accessibility: Dynamic Type and VoiceOverComing soon
    6. Animation and transitionsComing soon
  7. 7

    State and Data Flow

    The part of SwiftUI people fight with, explained before you have to.

    1. @State and the rendering modelComing soon
    2. @Binding, and passing state downComing soon
    3. @Observable and shared modelsComing soon
    4. @Environment and dependency passingComing soon
    5. Choosing the right property wrapperComing soon
  8. 8

    Lists and Navigation

    The two things almost every app is made of.

    1. List, and rendering collectionsComing soon
    2. Identifiable, and why the compiler is askingComing soon
    3. NavigationStack and pushing screensComing soon
    4. Sheets, alerts and confirmation dialogsComing soon
    5. Tab bars and app structureComing soon
    6. Forms and user inputComing soon
  9. 9

    Networking

    Talking to an API without freezing the interface.

    1. URLSession and fetching dataComing soon
    2. Codable: JSON into Swift typesComing soon
    3. async/await, and the main thread ruleComing soon
    4. Loading, empty and error statesComing soon
    5. Remote images and cachingComing soon
  10. 10

    Storing Data on Device

    What survives the app being closed, and what should not.

    1. UserDefaults, and what it is not forComing soon
    2. SwiftData: models and the containerComing soon
    3. Querying and updating stored dataComing soon
    4. Relationships between modelsComing soon
    5. Files, and secrets in the KeychainComing soon
  11. 11

    Meeting UIKit

    One module, because every real codebase still contains it.

    1. Why UIKit is still everywhereComing soon
    2. View controllers and the lifecycleComing soon
    3. Using UIKit views from SwiftUIComing soon
  12. 12

    Testing and Debugging

    Finding problems before your users file a one-star review.

    1. Breakpoints, the debugger and the view hierarchyComing soon
    2. Unit testing with Swift TestingComing soon
    3. UI testsComing soon
    4. Instruments: memory, leaks and slow framesComing soon
  13. 13

    Shipping to the App Store

    The part tutorials stop just before, and the part that decides whether anyone uses your app.

    1. Certificates, provisioning and signing, demystifiedComing soon
    2. App Store Connect and app recordsComing soon
    3. TestFlight and real testersComing soon
    4. App Review: what gets rejected and whyComing soon
    5. Privacy labels, permissions and App TrackingComing soon
  14. 14

    Capstone Project

    Design, build, test and submit a complete app.

    1. The brief: a habit trackerComing soon
    2. Designing it before building itComing soon
    3. Building it screen by screenComing soon
    4. Polish, icons and launch screenComing soon
    5. Submitting itComing soon
Previous courseAndroid Development with KotlinNext coursePython Django Web Development

Learning this with a mentor is faster

Our internship programme is free and fully remote. You get this curriculum, real project work, and code review from working developers.

Apply for the internshipAll courses