Swift 5.9 Released

Swift 5.9 is now available! 🎉

This is a major new release that adds an expressive macro system to the language and introduces support for integrating Swift into C++ codebases through bidirectional interoperability.

It also introduces parameter packs, an improved expression evaluator while debugging, enhanced crash handling, Windows platform improvements, and more.

Read on for a deep dive into changes to the language, standard library, tooling, platform support, and next steps for getting started with Swift 5.9.

Thank you to everyone in the Swift community who made this release possible. Your Swift Forums discussions, bug reports, pull requests, educational content, and other contributions are always appreciated!

Language and Standard Library

Swift’s fundamental goal is to encourage code that is clear and concise, while remaining safe and efficient.

This release adds three long-desired features that further that goal: a new macro system for more expressive libraries, parameter packs to make overloaded APIs natural to use, and new ownership features to offer more control over performance in low-level code.


Macros help developers reduce repetitive boilerplate and create more expressive libraries that can be distributed as a Swift package.

Using a macro is easy and natural. Macros can either be expanded with a function-like freestanding #macroName syntax:

let _: Font = #fontLiteral(name: "SF Mono", size: 14, weight: .regular)

or attached to declarations with an @MacroName attribute:

// Move storage from the stored properties into a dictionary,
// turning the stored properties into computed properties.
struct Point {
  var x: Int = 1
  var y: Int = 2

They work just like built-in language features but can’t be mistaken for normal code.

You write macros using a powerful and flexible approach: they are simply Swift functions that use the SwiftSyntax library to generate code to be inserted into the source file.

Macros make it easy for your library’s users to adopt powerful capabilities that adapt to the code they’re used in, like the new Observation module, which allows Swift classes to automatically notify other code when their properties change.

The Swift community has been hard at work creating tools and frameworks that build upon macros. For some examples, take a look at swift-power-assert, swift-spyable, swift-macro-testing, and MetaCodable.

Swift 5.9 supports macros on macOS and Linux, with Windows support coming soon.

Parameter packs

Parameter packs let you write generic types and functions which work over an arbitrary number of types.

For example, without parameter packs, if you wanted to write a function called all to check whether any number of Optional values are nil, you would need to write a separate overload for each argument length you wanted to support, creating an arbitrary upper limit:

func all<W1>(_ optional: W1?) -> W1?
func all<W1, W2>(_ optional1: W1?, optional2: W2?) -> (W1, W2)?
func all<W1, W2, W3>(_ optional1: W1?, optional2: W2?, optional3: W3?) -> (W1, W2, W3)?

With parameter packs, you can express this API as a single function that has no upper limit, allowing you to pass any number of arguments:

func all<each Wrapped>(_ optional: repeat (each Wrapped)?) -> (repeat each Wrapped)?

Calling an API that uses parameter packs is intuitive and requires no extra work:

if let (int, double, string, bool) = all(optionalInt, optionalDouble, optionalString, optionalBool) {
  print(int, double, string, bool)
else {
  print("got a nil")


Ownership features can help developers fine-tune memory management behavior in performance-critical code.

The new consume operator tells Swift to deinitialize a variable and transfer its contents without copying it. The consuming and borrowing parameter modifiers provide hints that Swift can use to eliminate unnecessary copying and reference-counting operations when passing a parameter. Finally, noncopyable structs and enums allow you to create types which, like a class, can’t be meaningfully copied when assigned, but like a struct or enum, do not need to be reference-counted because only one storage location can own the instance at a time.

These major features are the foundation for further evolution that puts more expressive power and performance control into your hands. We’re excited about what you can do with Swift 5.9, and we’re working toward a future with a larger suite of variadic generics and ownership features.

Additional Features

Swift 5.9 also includes smaller, quality-of-life changes to the language, like the ability to use if and switch as expressions for variable assignment and return values:

statusBar.text = if !hasConnection { "Disconnected" }
                 else if let error = lastError { error.localizedDescription }
                 else { "Ready" }

A new package access level lets other modules in the same package access APIs, but hides them from code outside the package. It’s great for splitting up large modules into several smaller ones without exposing internals to the package’s clients.

Developers using Swift Concurrency may appreciate the more convenient DiscardingTaskGroup types for task groups that don’t generate results and the advanced custom actor executors feature for controlling the exact environment that an actor is run in.

A full list of Swift 5.9 Evolution proposals can be found at the end of this post.

Developer Experience

Crash Handling

On Linux, the Swift runtime will now catch program crashes and Swift runtime errors and display a backtrace on the program’s output. The backtracer is out-of-process and includes support for async functions.

This feature is also available on macOS but is disabled by default. To enable it, set SWIFT_BACKTRACE=enable=yes and sign your program with the com.apple.security.get-task-allow entitlement.


Swift 5.9 introduces new features to LLDB and the Swift compiler aimed at making Swift debugging faster and more reliable.

The p and po commands now print local variables and properties as fast as the frame variable or v commands by bypassing the Swift compiler when evaluating simple expressions.

Swift expressions can now refer to generic type parameters. This allows setting a conditional breakpoint in a generic function that only triggers when a type parameter is instantiated with a specific concrete type.

The debug info produced by the Swift compiler now more precisely scopes local variables, making it less likely to display variables backed by uninitialized memory in the debugger.


C++ Interoperability

Swift 5.9 supports bidirectional interoperability with C++ and Objective-C++ for certain kinds of APIs.

For example, if you have a C++ function like:

// Clang module 'PromptResponder'
#pragma once
#include <vector>

std::vector<std::string> generatePromptResponse(std::string prompt);

you can call it directly from your Swift code:

import PromptResponder

let codeLines = generatePromptResponse("Write Swift code that prints hello world")
  .filter { !$0.isEmpty }

for line in codeLines {

C++ interoperability is actively evolving, with some aspects subject to change in future releases as the community gathers feedback from real world adoption in mixed Swift and C++ codebases.

For information on enabling C++ interoperability and the supported language subset, please refer to the documentation.

Special thanks to the C++ Interoperability Workgroup for their focus and dedication in supporting this feature.

Swift Package Manager

The Swift Package Manager has a number of improvements in Swift 5.9:

See the Swift Package Manager changelog for the complete list of changes.

Swift Syntax

swift-syntax is an essential tool for parsing Swift code and helps power the new macro system. This year, swift-syntax received a number of improvements:

Over the last year, swift-syntax has been a huge success as an open source project. Since the release of Swift 5.8, more than 30 distinct contributors have worked on the package, accounting for more than 30% of the commits. In addition, the community tool swift-ast-explorer.com is invaluable in exploring and understanding the SwiftSyntax tree. Thank you to everyone who contributed!


Custom actor executors and other features from Swift 5.9 are making their way into the Swift on server ecosystem.

The server workgroup also recently published their annual update for 2023, detailing plans to increase adoption of concurrency within key libraries, as well as other efforts.

Windows Platform

Windows support for Swift 5.9 greatly improves stability and the developer experience.

The Windows installer now supports installation both before and after Visual Studio installation, and no longer requires repair after a Visual Studio upgrade. Initial work has also begun to enable multiple, parallel toolchains installed side-by-side on Windows.

The Swift toolchain also added new flags (-windows-sdk-root, -windows-sdk-version, -visualc-tools-root, -visualc-tools-version) to help control the Windows SDK and Visual C++ tools that it builds against.

The Windows SDK (WinSDK) module saw improvements in coverage, enabling access to a wider set of system APIs. The Visual C++ (vcruntime) module was greatly restructured to support C++ interoperability.

Structured Concurrency is now significantly more stable on Windows, eliminating stack overflows and other execution failures for common patterns such as iterating over an AsyncStream with many elements.

Improvements to path handling in the LSP and SwiftPM makes both of these tools more robust on Windows. LLDB also saw initial work towards improving support for Windows, enabling fundamental debugging workflows in LLDB on Windows. While still a work in progress, this will significantly improve the developer experience on Windows.

Small improvements have also been made to reduce the size of the toolchain on Windows.

Next Steps


Official binaries are available for download from Swift.org for macOS, Windows, and Linux. The Swift 5.9 compiler is also included in Xcode 15.


Swift.org has revamped certain key pages, including a richer home page and clearer download and install instructions.

If you’re new to Swift or looking to dive deeper, check out the updated Getting Started guides.

Language Guide

The Swift Programming Language book has been updated for Swift 5.9 and is now published with DocC.

This is the official Swift guide and a great entry point for learning Swift.

The Swift community also maintains a number of translations.

Swift Evolution Appendix

The following language, standard library, and Swift Package Manager proposals were accepted through the Swift Evolution process and implemented in Swift 5.9.