swift.org
Swift 6.1 Released
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.
