01 · INTRODUCTION

What Is the Main Thread?

The short answer

The main thread is the first and primary stream of instructions created for a running application.

Every line of Swift we write eventually becomes instructions that must be executed by a processor.

CODE EXAMPLE

print("Line 1 — Program started")
print("Line 2 — The next instruction executes")
print("Line 3 — Swift source is compiled into machine code")
print("Line 4 — The processor executes those machine instructions")
print("Line 5 — A thread is one stream through those instructions")

When we read this code, our eyes naturally move from the first line to the second line and then to the third.

That is also the first useful way to imagine its execution.

The statements form one ordered script. After compilation, the resulting machine instructions are executed in sequence along one thread.

To understand the main thread, imagine those instructions packed into shipping containers.

Each container holds one instruction. The containers form a long single-file stream leading towards the processor.

EXECUTION DIAGRAM

OUR SWIFT CODE

let launch = loadLaunch()
launch.status = .ready
display(launch)

        │
        ▼

CONCEPTUAL INSTRUCTION STREAM

┌─────────────┐
│ Instruction │
│      1      │
└─────────────┘
        │
        ▼
┌─────────────┐
│ Instruction │
│      2      │
└─────────────┘
        │
        ▼
┌─────────────┐
│ Instruction │
│      3      │
└─────────────┘
        │
        ▼
   PROCESSOR CORE

The processor takes the instructions from that stream and executes them one after another.

Instruction 1 executes before Instruction 2. Instruction 2 executes before Instruction 3.

Only one instruction from this stream can be executing on one processor core at a particular instant.

This single-file stream gives us our first useful mental image of a thread.

💡 The First Mental Model

A thread is one stream of instructions moving through a running program.

The processor executes the instructions from that stream sequentially: one instruction at a time.

02 · TUTORIAL

From Swift Code to Processor Instructions

The processor cannot read Swift source code directly.

CODE EXAMPLE

let answer = 20 + 22
print(answer)

Before the application runs, the compiler transforms our Swift code into lower-level machine instructions that the processor understands.

EXECUTION DIAGRAM

Swift source code
       │
       ▼
Swift compiler
       │
       ▼
Machine instructions
       │
       ▼
Processor core executes those instructions

One line of Swift does not necessarily become one machine instruction.

A single Swift statement may require several processor instructions. The compiler may also combine, rearrange or remove operations while optimising the program.

Our shipping-container diagram is therefore a teaching model.

At first, we can imagine one container representing one line of Swift because that makes the flow easy to see. The more precise model is that each container represents one machine instruction produced from our compiled program.

EXECUTION DIAGRAM

TEACHING MODEL

One Swift line
      │
      ▼
One instruction container

MORE PRECISE MODEL

One Swift line
      │
      ▼
One or more machine instructions
      │
      ▼
Several instruction containers

The important idea remains the same: the processor ultimately works through an ordered stream of instructions.

03 · TUTORIAL

That Stream of Instructions Is a Thread

A thread is one path of execution through a running program.

It keeps track of the instruction currently being executed, the functions that led to that instruction and where execution should continue when each function returns.

Developers often describe a thread as a stream of instructions because this captures the most important part of the idea: one ordered sequence of work is progressing through the program.

CODE EXAMPLE

func prepareLaunch() {
    loadRocket()
    checkWeather()
    updateStatus()
}

func loadRocket() {
    print("Rocket loaded")
}

If prepareLaunch() is executing on the main thread, that same instruction stream enters loadRocket(), executes its instructions and then returns to the next instruction inside prepareLaunch().

EXECUTION DIAGRAM

MAIN THREAD

Enter prepareLaunch()
        │
        ▼
Call loadRocket()
        │
        ▼
Execute print("Rocket loaded")
        │
        ▼
Return to prepareLaunch()
        │
        ▼
Call checkWeather()
        │
        ▼
Call updateStatus()

It is still one stream.

💡 Important Terminology

Thread = one path of execution through a running process.

Instruction stream = a useful way to imagine the ordered instructions executed along that path.

Call stack = the thread's record of active function calls and where execution must return.

04 · TUTORIAL

Why Call It a "Thread"?

If a computer executed only one continuous path of instructions, we could simply describe that path as the program running.

The word thread becomes useful when the system is concurrent and several paths of execution exist.

Each thread is one continuous strand of execution. The operating system can pause one strand, run another and later return to the first.

The name comes from the real-world image of textile threads. One thread is one strand. Several threads can be woven together.

EXECUTION DIAGRAM

ONE THREAD

One continuous strand of instructions

────────────── A1 ── A2 ── A3 ── A4 ──────────────

A CONCURRENT SYSTEM

Several strands are interleaved over the same period

Thread A      A1 ── A2                A3 ── A4

Thread B                B1 ── B2

System thread                      S1 ── S2

A process with only one path of execution still has one thread. Concurrency makes the distinction important because that thread now exists alongside other threads competing for processor time.

This is why threads belong in an explanation of Swift Concurrency. Before Swift can schedule Tasks within our application, the operating system is already scheduling threads across the complete device.

05 · TUTORIAL

What Is a Process?

When iOS launches an application, it creates a running process for that application.

The process is the application's container while it is running.

It contains the application's memory, resources and threads.

EXECUTION DIAGRAM

RUNNING APPLICATION PROCESS

┌──────────────────────────────────────┐
│                                      │
│  Application memory                  │
│  Application resources               │
│  Open files and network connections  │
│                                      │
│  Main thread                         │
│                                      │
└──────────────────────────────────────┘

The process is not the thread.

The process is the running application container. A thread is one stream of execution inside that container.

An application can contain more than one thread, but every iOS application begins with a primary thread called the main thread.

06 · TUTORIAL

What Happens When the User Taps an App Icon?

Now we can follow an iOS application from the moment it begins.

The user taps the application's icon.

iOS receives a request to launch that application.

The operating system checks that the application can be launched, creates a new process for it when a new process is required, prepares its memory and resources, and creates the process's initial thread.

That initial thread becomes the application's main thread.

EXECUTION DIAGRAM

THE BIRTH OF AN iOS APPLICATION

User taps the app icon
        │
        ▼
iOS receives a launch request
        │
        ▼
iOS prepares the application process
        │
        ├── application memory
        ├── application resources
        └── initial thread
                 │
                 ▼
             MAIN THREAD
                 │
                 ▼
       program entry point begins

A newly launched program has a defined entry point. That entry point tells the system where execution of the program begins.

The application's first instructions begin on its initial thread.

This is why the words main function and main thread appear together so often: the program's main entry point begins executing on the process's initial thread.

💡 The App's First Moment

The process does not begin with every part of the application running.

It begins at one entry point, on one initial thread, with one ordered stream of instructions.

07 · TUTORIAL

The History of the main() Function

Many programming languages use a function named main() as the visible starting point of a program.

Historically, C, C++ and Objective-C programs commonly declared this function directly:

CODE EXAMPLE

func main() {
    print("Program started")
    loadApplicationState()
    createFirstWindow()
}

This Swift function is only a conceptual example. Declaring an ordinary function named main does not by itself make that function the entry point.

The important historical idea is simple:

EXECUTION DIAGRAM

Program is launched
        │
        ▼
main() begins
        │
        ▼
main() starts the program's higher-level systems

Older UIKit applications made this relationship visible through an Objective-C main function:

CODE EXAMPLE

#import <UIKit/UIKit.h>
#import "AppDelegate.h"

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(
            argc,
            argv,
            nil,
            NSStringFromClass([AppDelegate class])
        );
    }
}

UIApplicationMain performed the framework setup required to create the application object, establish the main event loop and begin processing events.

Modern Swift and SwiftUI hide more of this launch machinery, but the program still requires an entry point.

08 · TUTORIAL

What Does @main Mean in Swift?

Swift's @main attribute marks the type that provides the program's top-level entry point.

CODE EXAMPLE

@main
struct Program {
    static func main() {
        print("Program started")
    }
}

When the program launches, Swift calls the type's static main() method.

The function is static because the program needs somewhere to begin before it has created an instance of Program.

@main is part of the Swift language. It is not a SwiftUI feature.

SwiftUI uses this language feature by placing @main on a type that conforms to the App protocol:

CODE EXAMPLE

import SwiftUI

@main
struct RocketLaunchApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

We do not write the static main() method ourselves in an ordinary SwiftUI application.

The App protocol supplies the launch behaviour. The system calls the app conformer's main() method, and SwiftUI performs the framework setup needed to create the app and its scenes.

EXECUTION DIAGRAM

iOS launches the process
        │
        ▼
Initial thread begins
        │
        ▼
@main identifies RocketLaunchApp
        │
        ▼
RocketLaunchApp.main() launches the SwiftUI app
        │
        ▼
SwiftUI reads the App body's scene declarations
        │
        ▼
WindowGroup provides the application's window scene
        │
        ▼
ContentView becomes part of the initial interface

The body property is not itself an endless loop and it is not a handwritten replacement for every line inside main().

It is a declarative description of the scenes the application can create. SwiftUI and UIKit provide the surrounding application lifecycle and event-processing infrastructure.

09 · TUTORIAL

Why Is It Called the Main Thread?

It is called the main thread because it is the application's first and primary thread of execution.

Important application lifecycle and user-interface responsibilities are organised around it.

It means that this is the central thread around which the application is started and its important user-facing work is coordinated.

EXECUTION DIAGRAM

APP A PROCESS

┌──────────────────────────────────────┐
│                                      │
│  Main thread                         │
│  ┌──────────────────────────────┐    │
│  │ Application instructions     │    │
│  │ Event handlers               │    │
│  │ Important UI work            │    │
│  └──────────────────────────────┘    │
│                                      │
└──────────────────────────────────────┘