Swift Release Notes

You can now write Swift in a broader range of popular IDEs, including Cursor, VSCodium, AWS’s Kiro, and Google’s Antigravity. By leveraging VS Code extension compatibility, these editors tap directly into the Open VSX Registry, where the official Swift extension is now live.

Swift has long supported development using multiple IDEs including VS Code, Xcode, Neovim, and Emacs. Swift is also compatible with editors that implement the Language Server Protocol (LSP). This growing ecosystem of editor support is particularly significant as Swift continues to show its versatility across platforms and development environments, including agentic IDEs.

Swift on Open VSX

The Swift extension for VS Code is now officially available on the Open VSX Registry, the vendor-neutral, open source extension registry hosted by the Eclipse Foundation. The extension adds first-class language support for projects built with Swift Package Manager, enabling seamless cross-platform development on macOS, Linux, and Windows. This milestone brings Swift support, including code completion, refactoring, full debugging support, a test explorer, as well as DocC support, to a broader ecosystem of compatible editors and allows agentic IDEs like Cursor and Antigravity to automatically install Swift, with no manual download required.

Swift in Cursor, powered by the Swift extension on Open VSX.

Get Started

To start using the Swift extension in any Open VSX-compatible editor, simply open the Extensions panel, search for ‘Swift’ and install the extension.

If you’re using Cursor, getting started is easier than ever. Check out our new dedicated guide: Setting up Cursor for Swift Development. It walks you through the setup, features and includes how to configure custom Swift skills for your AI workflows.

Swift now has support for a wider range of modern editors and IDEs to meet developers where they are. Download the extension, try it out in your editor of choice, and don’t forget to share your feedback!

Original source Report a problem

Welcome to “What’s new in Swift,” a curated digest of releases, videos, and discussions in the Swift project and community.

Swift 6.3 has been released, expanding Swift into new domains and improving developer ergonomics. A highlight of its release is work to improve cross-platform build tooling. Owen Voorhees shares an update on that effort:

Hi! I’m Owen, a lead engineer on the Core Build team at Apple. Last year we shared our goal to bring Swift Build to Swift Package Manager, in an effort to deduplicate build technologies within the Swift ecosystem and deliver a consistent build experience across all platforms that Swift supports.

Since the announcement, we’ve been working in the open, landing hundreds of patches to improve Swift Build’s support across various platforms including Linux and Windows, and to integrate it deeply in Swift Package Manager. With Swift 6.3, developers have the option to enable this integration and try it out with their packages. To validate parity with the previous build system, we’ve used the package list from swiftpackageindex.com, testing thousands of open source packages with Swift Build.

Most recently, the main branch of Swift started using Swift Build as its default build system, paving the way for Swift Build to be the out-of-the-box option for Swift developers in a future Swift release.

Over the coming months, we’ll continue sharing our progress and driving down the remaining bugs to bring the build system to parity. We encourage you to give it a try and file bugs that you encounter. We’re excited by this progress, and look forward to building future tooling improvements across all platforms and project models that will benefit from this build system.

Now on to other news about Swift:

Videos to watch

• Interested in Swift for systems programming? The -ization of Containerization, presented at SCaLE, covers the Containerization project and their experience adopting Swift.
• Swift community meetup #8 featured two talks: real-time computer vision on NVIDIA Jetson, and a production AI data pipeline built with Vapor.
• A new interview with Matt Massicotte on the Swift Academy podcast goes in-depth on Swift Concurrency.

Community highlights

• How can you gradually deprecate APIs ahead of a major release? Point-Free blogged Hard Deprecations and Soft Landings with SwiftPM Traits, a clever approach to solving a common API deprecation problem.
• Daniel Jilg shared TelemetryDeck’s adoption story on the Swift blog, including how they use Swift and Vapor for backend services.
• The March 2026 Swift for Wasm updates are out, highlighting a new JavaScriptKit release with BridgeJS improvements, and continued work in WasmKit.

Swift Evolution

The Swift project adds new language features through the Swift Evolution process. These are some of the proposals currently under review or recently accepted for a future Swift release.

Under active review:

• SE-0522 Source-Level Control Over Compiler Warnings - Swift lets you configure warning behavior at the module level using compiler flags, but that’s an all-or-nothing approach. This proposal adds fine-grained warning control: a @warn attribute that lets you override warning behavior for a specific diagnostic group within the scope of a single declaration, with support for escalating it to an error, downgrading it to a warning, or suppressing it entirely, without affecting the rest of your module.

Recently accepted:

• SE-0509 Software Bill of Materials (SBOM) Generation for Swift Package Manager - An SBOM is a standardized inventory of all the software components in a project, increasingly required for security auditing and regulatory compliance. This proposal adds native SBOM generation to SwiftPM as both a --sbom-spec flag on swift build, and a separate swift package generate-sbom subcommand, with support for the CycloneDX and SPDX formats.
• ST-0021 Targeted Interoperability between Swift Testing and XCTest - When migrating from XCTest to Swift Testing, it’s common to call existing XCTest helper functions from new Swift Testing tests. Today, an XCTAssert failure inside a Swift Testing test is silently ignored. This proposal fixes that: XCTest APIs will work as expected when called in Swift Testing, and Swift Testing APIs will work as expected when called in XCTest, if XCTest already provides similar functionality.
• SE-0515 Allow reduce to produce noncopyable results - Swift’s reduce currently requires its initial value to be copyable, making it incompatible with noncopyable types. This proposal updates reduce to support noncopyable initial values and results, and changes it to consume rather than borrow the initial value, eliminating an unnecessary copy even for copyable types.

Original source Report a problem

Swift is designed to be the language you reach for at every layer of the software stack. Whether you’re building embedded firmware, internet-scale services, or full-featured mobile apps, Swift delivers strong safety guarantees, performance control when you need it, and expressive language features and APIs.

Swift 6.3 makes these benefits more accessible across the stack. This release expands Swift into new domains and improves developer ergonomics across the board, featuring:

• More flexible C interoperability
• Improvements to cross-platform build tooling
• Improvements for using Swift in embedded environments
• An official Swift SDK for Android

Read on for an overview of the changes and next steps to get started.

Language and Standard Library

C interoperability

Swift 6.3 introduces the @c attribute, which lets you expose Swift functions and enums to C code in your project. Annotating a function or enum with @c prompts Swift to include a corresponding declaration in the generated C header that you can include in your C/C++ files:

@c
func callFromC() {
    ...
}

// Generated C header
void callFromC(void);

You can provide a custom name to use for the generated C declaration:

@c(MyLibrary_callFromC)
func callFromC() {
    ...
}

// Generated C header
void MyLibrary_callFromC(void);

@c also works together with @implementation. This lets you provide a Swift implementation for a function declared in a C header:

// C header
void callFromC(void);

// Implementation written in Swift
@c
@implementation
func callFromC() {
    ...
}

When using @c together with @implementation, Swift will validate that the Swift function matches a pre-existing declaration in a C header, rather than including a C declaration in the generated header.

Module name selectors

Swift 6.3 introduces module selectors to specify which imported module Swift should look in for an API used in your code. If you import more than one module that provides API with the same name, module selectors let you disambiguate which API to use:

import ModuleA
import ModuleB
let x = ModuleA::getValue() // Call 'getValue' from ModuleA
let y = ModuleB::getValue() // Call 'getValue' from ModuleB

Swift 6.3 also enables using the Swift module name to access concurrency and String processing library APIs:

let task = Swift::Task {
    // async work
}

Performance control for library APIs

Swift 6.3 introduces new attributes that give library authors finer-grained control over compiler optimizations for clients of their APIs:

• Function specialization: Provide pre-specialized implementations of a generic API for common concrete types using @specialize.
• Inlining: Guarantee inlining — a compiler optimization that expands the body of a function at the call-site — for direct calls to a function with @inline(always). Use this attribute only when you’ve determined that the benefits of inlining outweigh any increase in code size.
• Function implementation visibility: Expose the implementation of a function in an ABI-stable library to clients with @export(implementation). This allows the function to participate in more compiler optimizations.

For a full list of language evolution proposals in Swift 6.3, see the Swift Evolution dashboard.

Package and Build Improvements

Swift 6.3 includes a preview of Swift Build integrated into Swift Package Manager. This preview brings a unified build engine across all supported platforms for a more consistent cross-platform development experience. To learn more, check out Preview the Swift Build System Integration. We encourage you to try it in your own packages and report any issues you encounter.

Swift 6.3 also brings the following Swift Package Manager improvements:

• Prebuilt Swift Syntax for shared macro libraries: Factor out shared macro implementation code into a library with support for swift-syntax prebuilt binaries in libraries that are only used by macros.
• Flexible inherited documentation: Control whether inherited documentation is included in command plugins that generate symbol graphs.
• Discoverable package traits: Discover the traits supported by a package using the new swift package show-traits command.

For more information on changes to Swift Package Manager, see the SwiftPM 6.3 Release Notes.

Core Library Updates

Swift Testing

Swift Testing has a number of improvements, including warning issues, test cancellation, and image attachments.

• Warning issues: Specify the severity of a test issue using the new severity parameter to Issue.record. You can record an issue as a warning using Issue.record("Something suspicious happened", severity: .warning). This is reflected in the test’s results, but doesn’t mark the test as a failure.
• Test cancellation: Cancel a test (and its task hierarchy) after it starts using try Test.cancel(). This is helpful for skipping individual arguments of a parameterized test, or responding to conditions during a test that indicate it shouldn’t proceed.
• Image attachments: Attach common image types during a test on Apple and Windows platforms. This is exposed via several new cross-import overlay modules with UI frameworks like UIKit.

The list of Swift Testing evolution proposals included in Swift 6.3 are ST-0012, ST-0013, ST-0014, ST-0015, ST-0016, ST-0017, and ST-0020.

DocC

Swift 6.3 adds three new experimental capabilities to DocC:

• Markdown output: Generate Markdown versions of your documentation pages alongside the standard rendered JSON covering symbols, articles, and tutorials. Try it out by passing --enable-experimental-markdown-output to docc convert.
• Per-page static HTML content: Embed a lightweight HTML summary of each page — including title, description, availability, declarations, and discussion — directly into the index.html file within a tag. This improves discoverability by search engines and accessibility for screen readers without requiring JavaScript. Try it out by passing --transform-for-static-hosting --experimental-transform-for-static-hosting-with-content to docc convert.
• Code block annotations: Unlock new formatting annotations for code blocks, including nocopy for disabling copy-to-clipboard, highlight to highlight specific lines by number, showLineNumbers to display line numbers, and wrap to wrap long lines by column width. Specify these options in a comma-separated list after the language name on the opening fence line:

let config = loadDefaultConfig()

let name = "World"       // highlighted
let greeting = "Hello"
print("\(greeting), \(name)!")  // highlighted

func example() { /* ... */ }

DocC validates line indices and warns about unrecognized options. Try out the new code block annotations with --enable-experimental-code-block-annotations.

Platforms and Environments

Embedded Swift

Embedded Swift has a wide range of improvements in Swift 6.3, from enhanced C interoperability and better debugging support to meaningful steps toward a complete linkage model. For a detailed look at what’s new in embedded Swift, see Embedded Swift Improvements coming in Swift 6.3.

Android

Swift 6.3 includes the first official release of the Swift SDK for Android. With this SDK, you can start developing native Android programs in Swift, update your Swift packages to support building for Android, and use Swift Java and Swift Java JNI Core to integrate Swift code into existing Android applications written in Kotlin/Java. This is a significant milestone that opens new opportunities for cross-platform development in Swift.

To learn more and try out Swift for Android development in your own projects, see Getting Started with the Swift SDK for Android.

Thank You

Swift 6.3 reflects the contributions of many people across the Swift community — through code, proposals, forum discussions, and feedback from real-world experience. A special thank you to the Android Workgroup, whose months of effort — building on many years of grassroots community work — brought the Swift SDK for Android from nightly previews to an official release in Swift 6.3.

If you’d like to get involved in what comes next, the Swift Forums are a great place to start.

Next Steps

Try out Swift 6.3 today! You can find instructions for installing a Swift 6.3 toolchain on the Install Swift page.

Original source Report a problem