Swift 6.3 and 6.4 landed at WWDC 2026 with a strong theme running through them: less boilerplate, fewer surprises, and more control. The session covers four broad areas — language improvements, library updates, cross-platform support, and performance. Here is a practical breakdown of everything announced.

Language Improvements

Better Swift Concurrency Diagnostics

The compiler now catches more concurrency mistakes and gives you clearer guidance when it does. Two patterns that previously slipped through are now properly diagnosed: catching errors inside a Task block, and saving a task reference for later rendezvous.

// Catching inside a Task
Task {
    do {
        try lander.fly(to: moon)
    } catch {
        lander.abort()
    }
}

// Saving a Task for later
let landingTask = Task {
    try lander.fly(to: moon)
}

defer {
    await orbiter.rendezvous(with: lander)
}

try await orbiter.justHangOut(waitingFor: landingTask)

Improved Sendable Conformances

Working with Sendable in class hierarchies just got more expressive. You can now mark a class as ~Sendable to opt out, and weak let properties are supported in Sendable types.

final class Spacecraft: Sendable {
    weak let dockedAt: SpaceStation?  // weak let now works in Sendable types
}

class Mission: ~Sendable { ... }

class CrewedMission: Mission, @unchecked Sendable { ... }

More Accessible Memberwise Initializers

Swift now generates multiple memberwise initializers at different access levels based on property visibility. If a struct has a mix of internal and private properties, you get both an internal initializer (without the private properties) and a private one (with everything). No more hand-writing boilerplate initializers just to work around access control.

struct Briefing {
    internal var topic: String
    internal var scheduledAt: Date
    private  var attendees: [Person] = []
}

// Swift generates both:
// internal init(topic:scheduledAt:)
// private  init(topic:scheduledAt:attendees:)

anyAppleOS Availability

Tired of spelling out every Apple platform in availability annotations? Swift 6.4 introduces anyAppleOS as a shorthand that covers iOS, macOS, watchOS, tvOS, and visionOS in one shot. Works in both @available attributes and #if conditions.

// Before
@available(macOS 27, iOS 27, watchOS 27, tvOS 27, visionOS 27, *)
func showStatus() { ... }

// After
@available(anyAppleOS 27, *)
func showStatus() { ... }

#if os(anyAppleOS)
func makeLiveActivityWidget() -> some Widget { ... }
#endif

You can still layer platform-specific exclusions on top:

@available(anyAppleOS 27, *)
@available(tvOS, unavailable)
func launch() { ... }

@diagnose — Fine-Grained Warning Control

The new @diagnose attribute lets you control how the compiler treats specific diagnostics on a per-declaration basis. You can silence a deprecation warning, promote a warning to an error, or demote a future error to a warning — all scoped to a single function.

// Silence a deprecation warning with a reason
@diagnose(DeprecatedDeclaration, as: ignored, reason: "Flying with surplus hardware")
func makeApolloSoyuzMission() -> Mission { ... }

// Treat strict memory safety as a warning instead of the default
@diagnose(StrictMemorySafety, as: warning)
func uplinkCommand(from receiver: inout Receiver, to computer: inout Computer) { ... }

// Treat a future Swift error as an error now, ahead of the version bump
@diagnose(ErrorInFutureSwiftVersion, as: error)
func fetchPosition() -> (x: Double, y: Double, z: Double) { ... }

Module Selectors (:: Syntax)

When two imported modules export the same name, Swift 6.3 gives you a clean way to be explicit: the double-colon module selector. It works on both types and members.

import Rocket
import GiftShopToys

let rocket2 = Rocket.SaturnV()   // ambiguous — prefers Rocket module's Rocket.SaturnV
let rocket3 = Rocket::SaturnV()  // unambiguous — definitely Rocket module's SaturnV

It also resolves method name conflicts from protocol extensions:

// Calls the HumanResources version of fire(), not Chemistry's
launchPadTechnician.HumanResources::fire()

Library Updates

withTaskCancellationShield

Sometimes a piece of work must complete even if the parent task is cancelled — like sending an emergency signal. The new withTaskCancellationShield wrapper protects a block of code from task cancellation, letting it run to completion regardless.

extension EmergencyTransponder {
    func sendSOS() {
        withTaskCancellationShield {
            radio.send(makeSOSPacket())
        }
    }
}

Dictionary.mapKeyedValues

A small but welcome addition. When you need to transform dictionary values while keeping access to the key, you previously had to construct the result manually. Now there is a purpose-built method for it.

// Before
let new: [Mission: String] = .init(
    uniqueKeysWithValues: missions.lazy.map { mission, launchWindow in
        (mission, makeDisplayName(for: mission, in: launchWindow))
    }
)

// After
missions.mapKeyedValues { mission, launchWindow in
    makeDisplayName(for: mission, in: launchWindow)
}

New FilePath Type

Foundation gains a new FilePath type that correctly handles macOS resource forks and named resources (the ..namedresource/rsrc path suffix). When iterating path components, it strips these platform-specific suffixes automatically.

var path: FilePath = "/var/www/static/..namedresource/rsrc"
print(path.components)
// [ "var", "www", "static" ]

Swift Testing: Issue Severity and Test Cancellation

Swift Testing picks up two improvements. First, you can now record an issue with a .warning severity — useful for soft failures that do not warrant stopping the test.

Issue.record(
    "\(rocket.name) remaining fuel is below 10% reserve target",
    severity: .warning
)

Second, Test.cancel lets a test stop itself early with a message, which is more expressive than skipping and cleaner than a conditional return.

if rocket.engineType == .solid {
    try Test.cancel("\(rocket.name) has solid fuel")
}

XCTest Interoperability

You can now freely mix XCTest assertions and Swift Testing expectations in the same codebase — calling XCTAssertEqual from a Swift Testing test, or using #expect inside an XCTestCase. Migration from XCTest no longer has to be all-or-nothing.

Subprocess Output Streaming

Subprocess now supports streaming output via .sequence, so you can process command output lazily as it arrives instead of waiting for the process to finish.

let result = try await Subprocess.run(.name("ls"),
                                      input: .none,
                                      output: .sequence,
                                      error: .string(limit: 4096)) { execution in
    execution.standardOutput.strings().filter { $0.hasSuffix(".obj") }
}

for try await objectFiles in result.closureOutput {
    print("Object file: \(objectFiles)")
}

Progress Reporting

A new ProgressManager API brings structured progress reporting with Swift concurrency support. Progress can be composed hierarchically using subprogress objects, and progress updates can be observed with Observations.

let manager = ProgressManager(totalCount: 100)
try await rocket.launch(mission.subprogress(assigningCount: 100))

Task {
    for await update in Observations({ mission.fractionCompleted }) {
        print("Mission \(Int(update * 100))%")
    }
}

Performance

Inlining Control: @inline(never) and @inline(always)

Swift now exposes explicit inlining attributes for when the optimizer needs a nudge. @inline(never) prevents a function from being inlined — useful for code size or debugging. @inline(always) forces inlining where the performance gain is known and worth it.

@inline(never)
func makeInts(randomized: Bool) -> [256 of Int] { ... }

@inline(always)
func makeInts(randomized: Bool) -> [256 of Int] { ... }

@specialized for Generic Functions

Generic functions generate a single implementation that works for all types. When a specific concrete type is used frequently, @specialized tells the compiler to emit a dedicated, fully optimized version for that type — getting the performance of a non-generic function without giving up the generic API.

@specialized(where Values == [UInt8])
func histogram<Values>(of values: Values) -> [256 of Int] where Values: Sequence<UInt8> {
    // Compiler emits a specialized version for [UInt8]
}

~Copyable and ~Escapable in Protocol Associated Types

Protocols can now express that their associated types do not need to be copyable or escapable, enabling more expressive and efficient protocol designs — particularly for iterator and span-based APIs that need to avoid unnecessary copies.

borrow and mutate Accessors

A new pair of accessors replaces the old get/set pattern for types that wrap unsafe pointers. borrow provides a read-only reference without copying; mutate provides a mutable reference. Together they allow non-copyable types to expose stored properties cleanly and safely.

public var value: Value {
    borrow { valuePointer.pointee }
    mutate { &valuePointer.pointee }
}

MutableRef for Hoisted Accesses

Subscript accesses inside loops — like updating a dictionary value — can result in repeated redundant lookups. MutableRef lets you hoist that access out of the loop manually, holding a stable mutable reference to the element for the duration of the operation.

var countRef = MutableRef(&counts[key, default: 0])

for set in sets {
    if set.contains(key) {
        countRef.value += 1
    }
}

Summary

The WWDC 2026 Swift session is less about dramatic new capabilities and more about sanding down the rough edges that have accumulated over the years. anyAppleOS removes genuine boilerplate. Better concurrency diagnostics catch real bugs. Module selectors solve real ambiguity problems. The performance additions — @inline, @specialized, MutableRef — hand meaningful control back to developers who need it without making the common case harder.

Swift 6.3 and 6.4 together represent a mature language tightening its tooling and ergonomics rather than chasing novelty.