How do @MainActor, global actors, isolated and nonisolated work, and how does isolation propagate?

Every piece of code has an isolation domain: an actor instance, a global actor, or none (nonisolated). A global actor is a single, shared actor you attach with an attribute; @MainActor is the built-in one for the main thread and UI, and you can declare your own with @globalActor. Put @MainActor on a type and all its members are isolated to the main actor (and, since it infers isolation, so are its subclasses, and types conforming to protocols declared @MainActor); put it on a function or property to isolate only that. Code outside the domain must await to reach isolated members, and synchronous access from a different domain is a compile error, such as mutating an actor’s property from a nonisolated function.

Isolation propagates in predictable ways. A closure or Task { } created in an isolated context inherits the isolation (a Task started from a @MainActor method runs on the main actor); Task.detached and @Sendable closures do not. An async function declared nonisolated runs on the global concurrent executor (not the caller’s actor) by default, which is the usual way to move heavy work off the main actor, and recent language versions let you choose to inherit the caller’s isolation instead (the nonisolated(nonsending) behaviour). nonisolated on a member of an actor makes it callable synchronously from outside, allowed only if it touches no isolated state (for example computing from let properties or conforming to Hashable). An isolated parameter (func f(_ a: isolated Bank)) makes the function run on that actor, so it can read the state synchronously. Hops between isolation domains cost a suspension and an await, so batch work: one hop to do several things, rather than many small calls. Use MainActor.assumeIsolated only when you can prove you are on the main thread, because it traps otherwise.