Optional parentheses around some / any#

You can now drop the parentheses when wrapping some or any types in an Optional:

1
// Before
2
func delegate() -> (any Renderer)?
3

4
// After
5
func delegate() -> any Renderer?

A tiny thing, but it removes a paper cut that every Swift programmer has hit.

weak let instead of @unchecked Sendable#

Previously a weak reference had to be a var, which made Sendable conformance awkward and often pushed people toward @unchecked Sendable. Swift 6.4 allows weak let for immutable weak references, so the type can be genuinely Sendable without the escape hatch.

~Sendable#

A new way to explicitly mark a type as non-Sendable — without that decision blocking subclasses from being Sendable. It makes intent legible instead of relying on the absence of a conformance.

Don’t silently swallow task errors#

Swift Concurrency now warns when you ignore an error thrown out of a Task. This is one of those “how did this not already warn” fixes — silently dropped task errors have caused real bugs.

defer can call async functions#

The old restriction on calling async functions inside a defer block is gone.

Two memberwise initializers#

A struct that mixes internal and private stored properties now synthesizes two memberwise initializers — one for each access level — instead of forcing you to hand-write one.

@diagnose — per-declaration warning control#

This is my favorite of the ergonomic batch. You can dial a specific diagnostic up or down on a single declaration:

1
@diagnose(DeprecatedDeclaration, as: ignored, reason: "Flying with surplus hardware")
2
func makeApolloSoyuzMission() -> Mission { ... }
3

4
@diagnose(StrictMemorySafety, as: warning)
5
func uplinkCommand(from receiver: inout Receiver, to computer: inout Computer) { ... }
6

7
@diagnose(ErrorInFutureSwiftVersion, as: error)
8
func fetchPosition() -> (x: Double, y: Double, z: Double) { ... }

No more flipping a warning project-wide just to handle one stubborn call site. And the reason: string doubles as documentation for the next person.

Module selectors :: (Swift 6.3)#

When two imported modules export the same name, you’ve historically had to play games with type aliases. Swift 6.3 adds a :: selector to name a symbol’s module unambiguously:

1
import Rocket
2
import GiftShopToys
3

4
let r1 = SaturnV()          // ambiguous
5
let r2 = Rocket::SaturnV()  // unambiguously the Rocket module's type

It works on members too — technician.HumanResources::fire() reaches past the collision.

Standard library#

• withTaskCancellationShield { ... } — run a critical section that must complete even if the surrounding task is cancelled (think: sending a final SOS packet).

• Dictionary.mapKeyedValues — transform values while keeping access to the key:

  1
  missions.mapKeyedValues { mission, window in
  2
      makeDisplayName(for: mission, in: window)
  3
  }
  

• FilePath — a real, cross-platform path type with structured components:

  1
  var path: FilePath = "/var/www/static"
  2
  path.components.append("WWDC")
  3
  // [ "var", "www", "static", "WWDC" ]
  

Swift Testing#

• Issue severity — Issue.record(..., severity: .warning) records a concern without failing the test.
• try Test.cancel("reason") — bail out of a parameterized case cleanly when it doesn’t apply.
• Flaky-test repetition — swift test can now repeat a test until it passes or fails, up to a configurable maximum, which is exactly what you want when chasing intermittent failures.
• XCTest interop — #expect works inside XCTestCase, and XCTest assertion failures surface as Swift Testing issues. Migration no longer has to be all-or-nothing.

Subprocess 1.0#

The Subprocess package hit 1.0 with a cleaner API, better error handling, and line-by-line streaming output that’s cross-platform (it abstracts over platform file descriptors and termination statuses):

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

Foundation: ProgressManager#

A new progress type built for async/await that separates composition from reporting. A parent allocates a slice of the total to a child via subprogress(assigningCount:), and the child reports against its own local stages without knowing the whole:

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

4
extension Rocket {
5
    func launch(_ progress: consuming Subprogress? = nil) async throws {
6
        let stage = progress?.start(totalCount: 3)
7
        try await ignite();          stage?.complete(count: 1)
8
        try await liftoff();         stage?.complete(count: 1)
9
        try await stageSeparation(); stage?.complete(count: 1)
10
    }
11
}

Foundation also continues its migration to pure Swift: faster Data operations and bridging, and a single unified Swift implementation behind NSURL/CFURL.

anyAppleOS — collapse availability boilerplate#

If you’ve ever written a six-platform @available line, this is for you:

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

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

It works in #if os(anyAppleOS) conditions too.

@C — call Swift from C#

The @C attribute exposes a Swift function directly to C (and lets Swift implement a C function), as long as the signature uses C-compatible types — integers, pointers, imported C structs, raw-value enums:

1
@C
2
func averageLaunchWindowLength(_ windows: Span<LaunchWindow>) -> TimeInterval { ... }

Swift–Java and Android#

async and throwing Swift functions are now callable from Java, Java classes can conform to Swift protocols, and — the big one — there’s an official Swift SDK for Android on swift.org.

WebAssembly#

Swift compiles to Wasm through an open-source toolchain, and JavaScriptKit’s type-safe bridging is now 35–40× faster than the dynamic path. Apple cited Goodnotes moving Swift code from native iOS straight to the web via Wasm.

Embedded Swift#

The embedded subset keeps growing without sacrificing binary size: existential types, untyped throws, and DWARF debug info for coredump debugging on constrained hardware. A new EmbeddedRestrictions warning group flags features that won’t survive in embedded contexts.

Editor support#

The Swift VSCode extension now integrates Swiftly for toolchain management and ships on OpenVSX, so Cursor, VSCodium, and friends get first-class Swift support — with a getting-started checklist for newcomers.

Optimizer hints#

• @inline(always) is now a supported attribute (pair it with final on class methods).

• @specialized (Swift 6.3) lets you pre-specialize a generic function for a concrete type you know is hot:

  1
  @specialized(where Values == [UInt8])
  2
  func histogram<Values>(of values: Values) -> [256 of Int]
  3
      where Values: Sequence<UInt8> { ... }
  

Ownership reaches the standard library#

Equatable, Comparable, and Hashable now work with noncopyable types, and Equatable/Comparable extend to non-escapable types. Associated types can be ~Copyable or ~Escapable. There’s also a new Iterable protocol whose for loops borrow elements instead of copying them.

New custom accessors make this practical to build on:

1
public struct UniqueBox<Value: ~Copyable>: ~Copyable {
2
    private let valuePointer: UnsafeMutablePointer<Value>
3

4
    public var value: Value {
5
        borrow { valuePointer.pointee }
6
        mutate { &valuePointer.pointee }
7
    }
8
}

New low-overhead types#

• UniqueBox / UniqueArray — noncopyable storage with no reference-counting overhead.

• Continuation — verifies single resumption at compile time: as safe as CheckedContinuation, as cheap as UnsafeContinuation.

• Ref / MutableRef — safe borrowed references into a collection slot:

  1
  var countRef = MutableRef(&counts[key, default: 0])
  2
  countRef.value += 1
  

• withTemporaryAllocation now hands you an OutputSpan instead of a raw UnsafeMutableBufferPointer.