What's new in Swift 6.4: cleaner syntax, safer concurrency and Subprocess

Swift 6.4 was released on 15 September 2026. After the big concurrency changes of Swift 6 and the easier defaults of Swift 6.2, this release focuses on everyday code: simpler syntax, safer clean-up in async code, a proper way to run other programs, and better tooling across platforms.

Simpler syntax for optional some and any

Optional opaque and existential types no longer need brackets (SE-0521).

// Before
func loadDashboard() -> (some View)? { ... }

// Swift 6.4
func loadDashboard() -> some View? { ... }

Choosing between modules with the same name

When two imported packages define the same function or type, module selectors (SE-0491) let you say which one you mean, with ::.

let a = ModuleA::getValue()   // the one from ModuleA
let b = ModuleB::getValue()   // the one from ModuleB

Concurrency: async clean-up that actually finishes

defer blocks can now contain await (SE-0493): the async work runs and finishes before the function exits. Cancellation shields (SE-0504) let clean-up code run even when the surrounding task has been cancelled, for example flushing metrics or closing a connection.

func syncReport(_ url: URL) async throws {
    defer {
        await withTaskCancellationShield {
            await flushMetrics(for: url)   // runs even if the task was cancelled
        }
    }
    try await upload(url)
}

Why it matters: apps and tools that move data, such as sync jobs and API clients, no longer lose their last log lines or leave connections open when a user cancels.

Subprocess 1.0: run other programs safely

A modern, async way to start other programs and read their output, on every platform Swift supports. It is ideal for command-line tools and automation scripts written in Swift.

import Subprocess

let result = try await Subprocess.run(
    .name("git"),
    arguments: ["log", "--oneline", "-5"],
    output: .string(limit: 4096)
)
print(result.standardOutput ?? "")

Tooling

• Swift Build is now the default build system in Swift Package Manager, giving one consistent build engine on macOS, Linux, Windows and Android.
• SBOMs: SwiftPM can generate software bills of materials in SPDX or CycloneDX format (SE-0509), useful for security reviews.
• Swift Testing gains interoperability with XCTest and repeated test runs.
• The VS Code extension is now on Open VSX, so it works in editors such as Cursor.
• Smaller debug builds and faster debugging, thanks to more precise module tracking in LLDB.

Platforms and interoperability

• WebAssembly: calling JavaScript from Swift is up to 40 times faster than the older dynamic bridging.
• Android: the Android SDK, first released with Swift 6.3, now builds with SwiftPM directly, with no extra setup script.
• C and C++: Swift can implement functions declared in C headers, and Span maps directly to C++20's std::span.
• Java: Swift and Java code can now call each other's async and throwing functions.
• Observation: @Observable types can deliver continuous, fine-grained change notifications (SE-0506).

What it means for data apps

If you build iPhone apps or widgets that display data, as in JSON in Swift with Codable, the concurrency changes make network and sync code more robust, and the simpler syntax makes SwiftUI code a little cleaner. For command-line data tools, Subprocess 1.0 makes Swift a more practical choice for automation.

Keep the Swift cheat sheet handy while you try the new features.

Source: the Swift.org announcement "Swift 6.4 Released" (15 September 2026) and the related Swift Evolution proposals. Check Xcode's release notes for which features need specific OS versions.

Alessandro Ecclesie AgazziWritten by Alessandro Ecclesie Agazzi, analytics engineer in London. Updated 13 October 2026. About me