Boost Swift Performance: Essential Optimization Tips for Mobile Developers

Some techniques can improve Swift code quality, making it less error‑prone and more readable. Explicitly marking final classes and class protocols are obvious examples, while other tricks may be non‑standard or only address temporary compiler or language quirks.

Enable Optimizations

-Onone: normal development, minimal optimization, retains all debug info. -O: default for most production code, aggressive optimizations, debug info omitted. -Ounchecked: special mode that removes overflow checks and some implicit type checks; use only when you are sure the code is safe.

The first thing to do is enable optimizations. Swift provides three optimization levels: Onone, O, and Ounchecked. Selecting the appropriate level can dramatically affect both compile time and runtime performance.

Whole‑Module Optimization

By default Swift compiles each file separately, which prevents some cross‑file optimizations. Activating whole‑module optimization (via the flag -whole-module-optimization or Xcode’s “Whole Module Optimization” setting) may increase compile time but can produce faster binaries.

Reduce Dynamic Dispatch

Swift’s default dynamic dispatch can be slower. Use final for classes, methods, or properties that are never overridden so the compiler can emit direct calls. Example:

final class C {
    var array1: [Int]
    func doSomething() { /* … */ }
}

class D {
    final var array1: [Int]   // cannot be overridden
    var array2: [Int]          // can be overridden
}

When a declaration does not need to be visible outside its file, mark it private. The compiler can then de‑virtualize calls and access properties directly.

Efficient Use of Container Types

Prefer value types in arrays and avoid bridging to NSArray. When a reference‑type array does not need to bridge to Objective‑C, use ContiguousArray instead of Array. Swift’s standard containers use copy‑on‑write (COW), so appending to a shared array triggers a copy only when necessary.

struct PhonebookEntry {
    var name: String
    var number: [Int]
}

var a: [PhonebookEntry] = []

When possible, replace Array with ContiguousArray for reference‑type elements that never bridge to Objective‑C.

Unchecked Arithmetic

If you know overflow cannot occur, use unchecked arithmetic (e.g., the &+ operator) to avoid runtime overflow checks.

Generics Specialization

When the optimizer can see concrete generic arguments, it can generate specialized code, eliminating generic overhead. Keep generic declarations in the same file where they are used, or rely on the standard library which is always visible to the optimizer.

Unmanaged References

For performance‑critical code, you can bypass ARC by using Unmanaged references and manually managing retain/release, reducing reference‑counting overhead.

Class‑Only Protocols

Mark protocols that are intended to be adopted only by classes with the : class constraint. This lets the compiler assume reference semantics and generate more efficient code, especially for ARC operations.

Footnotes:

【1】Virtual method table (vtable) is a lookup table of method addresses used for dynamic dispatch.

【2】The compiler may not know which concrete method will be called.

【3】Direct field access or direct method call.

【4】Explanation of copy‑on‑write (COW).

【5】In certain cases the optimizer can eliminate retain/release via inlining and ARC optimizations.