How Swift has evolved

Swift made its debut at the Worldwide Developers Conference (WWDC) in June 2014, surprising many in the tech industry. Swift was arguably the most significant announcement at WWDC 2014 and very few people, including Apple insiders, were aware of the project prior to it being announced.

Before we start to look at the language itself, let’s see how it has evolved.

Swift was born

Development of the Swift language itself can be traced back to 2010 when Apple’s Senior Director of Developer Tools, Chris Lattner, started designing the basic concepts for a new language. At the time, Apple was heavily reliant on Objective-C, which had been their primary language since the 1980s. While Objective-C had served Apple well, the company recognized the need for a more modern and safer language, but also the need for a language that could seamlessly interoperate with existing Objective-C code, allowing developers to adopt Swift incrementally without rewriting entire codebases.

The introduction of Swift wasn’t just another product launch; it marked a significant shift in Apple’s programming landscape. The announcement demonstrated Apple’s commitment to pushing boundaries and redefining how software for Apple’s devices was written. In addition, it demonstrated Apple’s commitment to the developer community, which has only grown stronger as Swift has evolved.

Swift evolved

At WWDC 2015, Apple continued the evolution of Swift by announcing Swift 2, which brought substantial improvements to the language. What was particularly noteworthy was that these enhancements were based on feedback directly from the developer community. This highlighted Apple’s willingness to listen and adapt, fostering a more collaborative environment with the developer community.

However, the most significant announcement of WWDC 2015 was arguably the decision to make Swift an open-source project. This move not only increased access to the language but also encouraged collaboration and innovation on a broader scale. It also represented a departure from Apple’s traditional closed-door approach and a move to a more inclusive future of software development.

Four years later, in 2019, Swift 5.0 was officially released, introducing a stable version of the application binary interface (ABI) across Apple’s platforms. This was a major step forward because it addressed a longstanding challenge of binary compatibility, enabling Swift code compiled with one version of the compiler to interact with code compiled with future versions. This ensured compatibility and stability as Swift evolved. Developers could now confidently distribute precompiled libraries, knowing they would remain compatible with future versions of Swift. This binary compatibility is crucial for the long-term sustainability of the language.

The stable ABI reinforced Swift’s position as a versatile language for building cross-platform applications across Apple’s devices. With binary compatibility now guaranteed across different platforms, developers could leverage Swift to target a broader range of devices and operating systems, including iOS, macOS, watchOS, visionOS, and tvOS. This cross-platform capability enabled developers to write code once and deploy it across the various platforms, streamlining the development process.

The Swift 5 release, coupled with the stable ABI, was a crucial moment in Swift’s evolution, providing developers with a stable foundation for building high-performance, cross-platform applications.

Looking back at the history of Swift, it illustrates Apple’s dedication to innovation and collaboration. These milestones have not only reshaped the programming landscape but have also set a new precedent for how technology companies engage with their developer communities.

Let’s explore the history of the Swift language in more detail to see how it evolved at each step. This will give us a better understanding of how we arrived at Swift 6.

Table 1.1: History of Swift

What’s new with Swift 6?

WWDC 2024 marked a significant milestone for the Swift language. Not only was Swift 6 announced, but it also celebrated the 10th anniversary of Apple announcing Swift at WWDC 2014. Swift 6.0 was released in September 2024 and promised to shape the future of the language, building upon the foundation of the previous releases and introducing several new features and enhancements focused on improving developer productivity, performance, and reliability.

One of the major new features of Swift 6.0 is cross-compilation, which enables developers to compile code on macOS devices and then deploy it on the Linux platform.

Another important enhancement is the Swift Testing framework, which takes advantage of modern Swift features to provide a suite of tools for writing and executing tests, ensuring code quality and reliability.

Additionally, Swift 6.0 introduces typed throws, a feature that enhances error handling by enabling functions to specify the types of errors they can throw. This improvement makes error management more explicit and predictable, which will improve code clarity and safety.

Data race safety is another crucial feature, providing built-in mechanisms to prevent concurrent data access issues, which improves the stability and reliability of multi-threaded applications. Strict concurrency checking was also introduced with Swift 6, which enforces rules at compile time to ensure that code adheres to Swift’s structured concurrency model, helping developers catch potential issues early and write safer, more predictable concurrent code.

Finally, embedded Swift expands the language’s capabilities into the area of embedded systems, enabling developers to write Swift code for a much wider range of hardware.

These features, combined with additional enhancements in Swift 6.0, position it as a powerful and versatile language set to drive innovation in software development for years to come.

After Swift 6.0 was announced, Swift continued to improve with the release of Swift 6.1 and Swift 6.2, both bringing powerful new capabilities to the language and its new testing infrastructure. Swift 6.1 extended key paths to support static properties of types. On the testing side, Swift 6.1 added range-based count confirmations, enabling tests to validate on a range in a clear and readable syntax.

With WWDC 2025, and the announcement of Swift 6.2, came several highly requested features, including the addition of the new Observation struct, which adds a flexible way to watch changes in your data outside of SwiftUI. Another important enhancement was the ability to name tasks.

However, one of the most impactful changes was SE-0466, which enabled default single-actor execution to effectively set your applications back to being single-threaded. Swift Testing was also expanded with the addition of exit tests using #expect(processExitsWith:), allowing developers to safely test code paths that may terminate the process.

If you have existing projects, it is pretty straightforward to migrate them to Swift 6. Let’s take a look at how to do this.