iOS Engineer

What the platform does, why it is built this way, and — importantly — the places where the in-browser Swift runtime is a model rather than the real thing.

The teaching method

Every lesson follows the same shape, and each part of that shape is there because of a specific, well-replicated finding about learning technical material.

Part of a lesson	Why it is there
Guess first — a question before you have read anything	Attempting to answer before instruction improves later retention, even when the guess is wrong. Being wrong first is a feature, not a cost.
Predict, then run	Committing to a prediction turns reading into a test. A prediction that fails produces a much sharper correction than an explanation you merely nodded along with.
Concrete before abstract	Every rule arrives attached to a runnable example first. Abstractions introduced before the concrete case they generalise tend not to stick.
Graded exercises	Practice with immediate, specific feedback. Hints reveal one at a time, and the solution stays locked until you have genuinely tried — a solution read too early removes the work that produces the learning.
Write it in your own words	Explaining something without looking is the cheapest honest test of understanding there is. Nothing grades these; the value is entirely in the retrieval.
Spaced review	Cards return just before you would have forgotten them, scheduled by FSRS-5. Cards from different lessons are interleaved, because blocked practice feels easier and retains worse.
Confidence rating	Rating yourself and then being measured exposes where your sense of your own knowledge is wrong. That gap is the most useful thing on the progress page.

What this deliberately does not have

Streaks. They reward opening the app, not learning, and reliably produce token sessions taken to protect a number.
Points, badges, leaderboards. There is one learner. Mastery is the reward.
Video. Watching someone else type produces a strong feeling of understanding and very little of it.

The Swift runtime

Swift in the lessons is real execution, not a recording. This site ships a Swift interpreter written in TypeScript — a lexer, a parser, and a tree-walking evaluator — that runs entirely in your browser tab. SwiftUI is implemented on top of it: view constructors build a view tree, and that tree is rendered to HTML in a device frame beside the editor.

It covers the language this curriculum teaches:

Values, optionals, control flow, functions, closures, string interpolation
Structs, classes, enums with associated and raw values, value vs. reference semantics
Protocols, protocol extensions with default implementations, generics
Errors: throw, do/catch, try?, defer
Concurrency: async/await, Task, async let, task groups, actors
SwiftUI: stacks, lists, shapes, modifiers, ForEach, custom views, previews

Where it diverges from real Swift

These are stated plainly because a teaching tool that hides its own limits teaches wrong things:

There is no type checker. Real Swift rejects type errors before running. Here they surface when the line executes. The error messages are written to explain the same rule the compiler would have enforced, but the timing is different.
Optionals are not boxed. Printing an optional shows Optional(5) in Xcode; here it shows 5. The unwrapping rules themselves — if let, guard let, ??, ! trapping on nil — all behave correctly.
Concurrency is deterministic. The scheduler is single-threaded with a virtual clock, so ordering is reproducible and lessons can assert on output. Every ordering it produces is one real Swift is permitted to produce, but on a device the interleaving may differ. Task.sleep advances the virtual clock instantly.
SwiftUI previews are static. Tapping a button does not change state. The layout model reproduces stacks, spacers, frames, padding and alignment, but it is a model — the real layout algorithm has behaviours it does not capture.
SF Symbols are stand-ins. Apple's symbol font cannot be redistributed, so common symbols render as approximations and the rest as labelled placeholders.
Randomness is seeded. shuffled() and randomElement() are reproducible so lesson output can be checked.

Anything the runtime cannot model honestly is flagged in-lesson as an Xcode task — something to do in the real toolchain, because some things simply cannot be learned in a browser.

What this curriculum is for

Finishing it should leave you able to read any Swift codebase, reason about ownership and concurrency, build non-trivial SwiftUI interfaces, and make architectural decisions with reasons behind them. Currently 55 lessons, 120 exercises, and 249 recall cards across five tracks.

What it cannot give you is the thing only shipping gives you: the judgement that comes from maintaining an app through real users, real crash reports, and real App Review rejections. The Xcode tasks exist to push you toward that as early as possible.

Your data

There is no account. Progress, review schedules, exercise attempts and notes live in IndexedDB in this browser, and by default nothing is transmitted anywhere. Clearing site data clears your progress, so export a backup from the progress page if it matters to you.