Swift 6.1 Released

Holly Borla Holly Borla

Swift 6.1 is now available!

This release includes new language enhancements to improve productivity, diagnostics improvements, package traits, and ongoing work to improve data-race safety usability and compile times.

Read on for an overview of the changes to the language, package manager, and next steps for getting started with Swift 6.1.

Language and Standard Library

Concurrency

Swift’s concurrency model allows writing nonisolated on properties and functions to indicate that an API is safe to call from any concurrent context. Swift 6.1 extends nonisolated to types and extensions. This allows you to write nonisolated to prevent @MainActor inference on a type, or to apply nonisolated to all methods in an extension without having to annotate every method:

@MainActor
struct S {
  let id: Int
  let name: String

  // mutable state and MainActor methods
}

nonisolated extension S: CustomStringConvertible, Equatable {
  var description: String {
    "id: \(id), name: \(name)"
  }

  static func ==(lhs: S, rhs: S) -> Bool {
    lhs.id == rhs.id
  }
}

Swift 6.1 also improves type inference for task groups by inferring the child task result type of withTaskGroup and withThrowingTaskGroup. Previously, you always had to write the child task result type as an argument when creating the task group:

let messages = await withTaskGroup(of: Message.self) { group in
  for id in ids {
    group.addTask { await downloadMessage(for: id) }
  }

  var messages: [Message] = []
  for await message in group {
    messages.append(message)
  }
  return messages
}

In Swift 6.1, the child task result type can be inferred from the task group closure:

// No need for `(of: Message.self)` like before.
let messages = await withTaskGroup { group in
  for id in ids {
    group.addTask { await downloadMessage(for: id) }
  }

  var messages: [Message] = []
  for await message in group {
    messages.append(message)
  }
  return messages
}

The approachability of data-race safety remains an area of active development; you can find an overview of the approach in the vision document for improving the approachability of data-race safety. Many Swift Evolution proposals implementing the features described in the vision document are under active review, and your feedback will help shape these improvements.

Implementing Objective-C types in Swift

Swift 6.1 includes a new attribute, @implementation, which can be used together with @objc to provide an implementation for a declaration that has been imported from Objective-C. You can write @objc @implementation on a Swift extension to replace an Objective-C @implementation block.

You write headers as normal for an Objective-C class, but instead of writing an @implementation in an Objective-C file, you write an @objc @implementation extension in a Swift file. You can even port an existing class’s implementation to Swift one category at a time without breaking backwards compatibility.

Productivity enhancements

Swift allows including trailing commas in collection literals to make it easy to append, remove, reorder, or comment out the last element as any other element:

let rank = [
  "Player 1",
  "Player 3",
  "Player 2",
]

Swift 6.1 extends trailing comma support to tuples, parameter and argument lists, generic parameter lists, closure capture lists, and string interpolations:

let numbers = [1, 2, 0, 3, 4, 0, 0, 5]

let subsequences = numbers.split(
    separator: 0,
    maxSplits: 1,
)

In addition to improved development ergonomics, code generation tools like plugins and macros can be simplified, because generating a comma-separated list no longer needs a special condition for the last element.

You can find a complete list of language proposals that were accepted through the Swift Evolution process and implemented in Swift 6 on the Swift Evolution dashboard.

Package and build improvements

Swift 6.1 introduces package traits, a new configuration for packages that allows them to offer different APIs and features when used in specific environments, such as Embedded Swift and WebAssembly. Package authors can define a set of traits in their Package.swift that their package offers, which provide a way to express conditional compilation and optional dependencies. The package can specify a set of default traits that are enabled in clients, and clients can customize the traits they use when they declare the dependency:

dependencies: [
  .package(
    url: "https://github.com/Org/SomePackage.git",
    from: "1.0.0",
    traits: [
      .default, // enable all of the package's default traits
      "Embedded"
    ]
  ),
]

Many editing features, such as jump to definition for APIs in libraries you’re using, are powered by indexing. Before Swift 6.1, indexing occurred when you built your project, which meant that any additions or changes to the library were only surfaced by those editing features after you perform a build. Swift 6.1 enables background indexing by default for SwiftPM projects in SourceKit-LSP. Cross-module and global functionality stays updated as you make changes to your project.

Swift Testing

Swift 6.1 enables custom Swift Testing traits to perform logic before or after tests run in order to share set-up or tear-down logic. If you write a custom trait type which conforms to the new TestScoping protocol, you can implement a method to customize the scope in which each test or suite the trait is applied to will execute. For example, you could implement a trait which binds a task local value to a mocked resource:

struct MockAPICredentialsTrait: TestTrait, TestScoping {
  func provideScope(for test: Test, testCase: Test.Case?, performing function: @Sendable () async throws -> Void) async throws {
    let mockCredentials = APICredentials(apiKey: "fake")
    try await APICredentials.$current.withValue(mockCredentials) {
      try await function()
    }
  }
}

extension Trait where Self == MockAPICredentialsTrait {
  static var mockAPICredentials: Self { Self() }
}

@Test(.mockAPICredentials)
func example() {
  // Validate API usage, referencing `APICredentials.current`...
}

For more details, see ST-0007: Test Scoping Traits. Swift Testing in Swift 6.1 also includes refined versions of the #expect(throws:) and #require(throws:) macros which return their caught errors, making inspecting them in test functions more ergonomic (ST-0006).

Swift-DocC

Swift-DocC introduces a more human readable and human writable alternative for symbol link disambiguation based on parameter type and return type information. For example, consider these three function overloads with different parameter types and return types:

func doSomething(first: String,  second: Int) -> Double
func doSomething(first: String?, second: Int) -> Float
func doSomething(first: String?, second: Int) -> Double

Previously, if you wrote a link to one of these overloads you needed to include a short hash of that symbol’s unique identifier to disambiguate the link and uniquely reference the specific overload. Swift-DocC’s warnings aided in writing these hashes but a person can’t decode the resulting hash suffix (-3c5j) to determine which overload the link is referring to. Now, you can use a combination of parameter types and return types—like -(String,_), ->Float, or -(String?,_)->Double—to disambiguate the link and uniquely reference a specific overload.

You can discover the minimal combination of parameter types and return types for each overload from Swift-DocC’s warnings about ambiguous symbol links. For more details, see the Ambiguous Symbol Links section of Linking to Symbols and Other Content.

Install Swift 6.1

You can try out these exciting new developments in Swift 6.1 today!

If you’re building apps for Apple platforms, Swift 6.1 is included in Xcode 16.3, now available from the App Store. And the easiest way to install the standalone Swift 6.1 toolchain is using swiftly, the new Swift version manager that runs on macOS and Linux. Additional installation methods, including for Windows, are included on the Install Swift page.