Unlock exclusive free benefits that come with your purchase, thoughtfully crafted to supercharge your learning journey and help you learn without limits.

Here’s a quick overview of what you get with this book:

Next-gen reader

Figure 1.1: Illustration of the next-gen Packt Reader’s features

Our web-based reader, designed to help you learn effectively, comes with the following features: Multi-device progress sync: Learn from any device with seamless progress sync. Highlighting and notetaking: Turn your reading into lasting knowledge. Bookmarking: Revisit your most important learnings anytime. Dark mode: Focus with minimal eye strain by switching to dark or sepia mode.

Interactive AI assistant (beta)

Figure 1.2: Illustration of Packt’s AI assistant

Our interactive AI assistant has been trained on the content of this book, to maximize your learning experience. It comes with the following features: Summarize it: Summarize key sections or an entire chapter. AI code explainers: In the next-gen Packt Reader, click the Explain button above each code block for AI-powered code explanations. Note: The AI assistant is part of next-gen Packt Reader and is still in beta.

DRM-free PDF or ePub version

Figure 1.3: Free PDF and ePub

Learn without limits with the following perks included with your purchase: Learn from anywhere with a DRM-free PDF copy of this book. Use your favorite e-reader to learn using a DRM-free ePub version of this book.

Unlock this book’s exclusive benefits now Scan this QR code or go to packtpub.com/unlock, then search for this book by name. Ensure it’s the correct edition.
Note: Keep your purchase invoice ready before you start.

Now let’s begin our journey by looking at the evolution of the Swift language.

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.

To migrate an existing project to use Swift 6, you generally just need to adjust the building settings for that project. This is how to do it:

1. Open the project in Xcode 16.
2. In the Project Navigator, click on the top-level project file.
3. At the top of the editor panel, you should see several tabs: Info, Build Settings, Package Dependencies, and so forth. Click on Build Settings.
4. There are a lot of settings within Build Settings; we need to scroll down to the Swift Compiler settings. To make it easier, we could filter for Swift using the search bar.
5. Under the Swift Compiler settings, look for the Swift Language Version setting and set it to Swift 6.

Figure 1.4: Setting the Swift language version to Swift 6

6. Clean and rebuild your project.

That is it; we are now using the Swift 6 compiler to build our project.

Now that we’ve explored the history of the language leading up to Swift 6.0 and seen how to migrate our project to Swift 6, let’s look into ways developers can engage with the Swift community.

When Apple first open-sourced the Swift programming language in 2015, they also launched the swift.org website. This site serves as the central hub for all things related to Swift, providing a variety of resources to support developers at different stages of their journey. Over the years, this site has evolved into a comprehensive resource center, serving as a gateway for developers to explore, learn, and contribute to the Swift ecosystem.

Comprehensive documentation and guides

The swift.org site hosts official documentation along with numerous guides designed to assist developers in exploring the Swift ecosystem. Additionally, it offers detailed articles covering a wide array of Swift topics, including server-side development, compatibility with C++, API design guide, and distinctions between value and reference types. These valuable resources give developers a thorough understanding of the language’s features and complexities.

The Swift standard library and Core Libraries

One essential resource within the swift.org site is the documentation for the Swift standard library and the Core Libraries.

These libraries provide a wide range of functions that are usable across all platforms supported by Swift. The standard library contains the essential building blocks for writing Swift programs, while the Core Libraries offer more advanced features.

The Swift Package Manager

The Swift Package Manager is another critical component of the swift.org ecosystem. It simplifies the process of managing and distributing Swift code packages. It also automates the tasks of downloading, compiling, and linking dependencies. With this tool, developers can easily add third-party libraries and frameworks to their projects, making development and the compiling process smoother.

Continuous integration and source compatibility

To keep Swift stable, the swift.org site also manages the project’s continuous integration (CI) system and source compatibility test suite. These tools are essential for maintaining the language’s integrity by conducting thorough tests on active branches and a collection of Swift source code.

Contributing to Swift

For developers who wish to take an active role in shaping the future of Swift, the swift.org site provides information on how to contribute to the community. It explains the Swift evolution process, which decides how Swift evolves, and provides tips on suggesting changes and joining discussions. Additionally, the website shares the source code for the Swift project itself, letting developers look into how Swift works, report problems, and propose improvements with pull requests.

A thriving community

At the core of the swift.org ecosystem is a thriving community of developers, contributors, and enthusiasts. Through forums and communication channels on the website, members can collaborate, help each other, and discuss the future of the Swift language. By fostering this community, the swift.org site has become the center of innovation, helping developers learn, progress, and influence the future of the Swift language.

The swift.org site is a comprehensive resource, offering developers a vast collection of documentation, guides, libraries, and tools for the Swift language. Whether you’re just starting out or are already an experienced Swift developer, the site probably has something valuable to offer you, making it a key destination for anyone interested in developing professionally with Swift. I truly hope you explore it and become a part of the Swift community.

In this chapter, we started by looking at how the Swift language has progressed over time. By understanding the history of the language, we gain a better appreciation of the hard work and dedication that have gone into making the language what it is today. We also get a better understanding of why certain features or design choices were made.

We concluded this chapter with a section introducing the swift.org website, which is an essential resource for the Swift community, offering incredibly valuable documentation, collaboration opportunities, and support for developers of all levels.

In the next chapter, we will explore closures, self-contained blocks of functionality, and result builders, which allow us to create custom domain-specific languages.