Skip to content

Swift and the Post-Objective-C Era

Abstract

Swift was unveiled by Apple on 2 June 2014 as the successor to Objective-C, the language that had carried NeXT, the Mac and the iPhone for a quarter of a century. Chris Lattner, the author of the LLVM compiler infrastructure, started it alone and in secret in July 2010. Swift moved null-pointer crashes, unchecked integer overflow and later data races from runtime into the compiler. Apple open-sourced it in December 2015, broke its source compatibility three times before stabilizing the binary interface in 2019, and replaced the old imperative UI style with SwiftUI. Outside Apple’s platforms it found a narrower audience than its founders hoped: IBM left server-side Swift in 2019, Google archived Swift for TensorFlow in 2021, and the Ladybird browser dropped its Swift plans in 2026.

Chris Lattner FOSDEM 2011
Chris Lattner speaking about LLVM at FOSDEM in Brussels, February 2011, seven months after he had started Swift in private. Image: Alexandre Dulaunoy, CC BY-SA 2.0, via Wikimedia Commons.

The Objective-C Inheritance

NeXTcube CHM
NeXTcube (1990) at the Computer History Museum. NeXTSTEP and its Objective-C frameworks became the foundation of Mac OS X and iOS. Image: Michael Hicks, CC BY 2.0, via Wikimedia Commons.

Objective-C came out of a corporate research lab. Brad Cox and Tom Love met Smalltalk at ITT’s Programming Technology Center in 1981 and wanted its message-passing objects without giving up C, the language their colleagues already wrote. Their answer was a preprocessor-style extension: plain C, plus a bracket syntax for sending messages to objects ([window setTitle:@"Hello"]) and a small runtime that looked up methods by name while the program ran. They sold it through their company, Productivity Products International, later renamed Stepstone, and Cox described it in his 1986 book Object-Oriented Programming: An Evolutionary Approach.

The language would have stayed a niche product had Steve Jobs not needed one. In 1988 NeXT licensed Objective-C from Stepstone and added it to the GNU C compiler. NeXT first planned to ship its Objective-C front end as a separate, proprietary piece. Richard Stallman consulted the Free Software Foundation’s lawyers, who concluded that this would violate the GPL, and NeXT released the code. The episode left the GNU compiler with Objective-C support and left Apple, years later, with an uneasy dependence on a compiler whose license it disliked.

When Apple bought NeXT, NeXTSTEP became Mac OS X (see The macOS Lineage), and its Objective-C frameworks became Cocoa. The iPhone SDK of 2008 added Cocoa Touch on the same base. A language invented for a niche market in the early 1980s was suddenly what every App Store developer had to learn.

Apple modernized it in steps. Objective-C 2.0, announced at WWDC 2006 and shipped with Mac OS X 10.5 in October 2007, added declared properties, fast enumeration and an optional garbage collector. The collector never caught on; Apple deprecated it in OS X 10.8 in favor of Automatic Reference Counting (ARC), which arrived with the LLVM 3.0 compiler in Xcode 4.2 in 2011. ARC let the compiler insert the retain and release calls programmers had written by hand for twenty years. Literal syntax for arrays and dictionaries followed in 2012.

The patches could not remove what lay underneath. Objective-C was C, with C’s raw pointers, undefined behavior and header files. Sending a message to nil silently did nothing, which hid bugs instead of reporting them. Collections such as NSArray held untyped objects. Most of all, the language looked strange to newcomers who had learned Java, JavaScript or Python; the square brackets and long, keyword-interleaved method names (stringByReplacingOccurrencesOfString:withString:) were a barrier at the door of the most profitable app platform in the world.

Lattner’s Side Project

Chris Lattner had arrived at Apple in July 2005, fresh from his PhD at the University of Illinois, where he had built LLVM with his adviser Vikram Adve. At Apple he started Clang, a new C, C++ and Objective-C front end on top of LLVM, which by 2012 had replaced GCC in Xcode. The compiler work gave him a close view of Objective-C’s limits. ARC itself was a compiler feature: making Objective-C safer meant teaching the compiler more about the program than the language could express.

His own account of what came next is brief: “I started work on the Swift Programming Language in July of 2010. I implemented much of the basic language structure in secrecy: A few other folks started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013.” For over a year it was an evenings-and-weekends project known to a handful of people. Lattner listed its influences as “Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list”. The interactive Playgrounds, in which code results appear beside each line as it is typed, were his personal interest and drew on Bret Victor’s demonstrations and the Light Table editor.

The design brief had a constraint none of those languages had faced. Swift had to call every existing Objective-C framework from day one and run in the same process as Objective-C code, because Apple could not ask developers to throw away the Cocoa APIs. Swift therefore uses the Objective-C runtime on Apple platforms, imports Objective-C headers through Clang, and exposes Swift classes back to Objective-C. The same requirement explains several Swift oddities, such as the @objc attribute and argument labels that mirror Objective-C’s interleaved method names.

The Announcement

Apple introduced Swift at the WWDC keynote on 2 June 2014. Craig Federighi, Apple’s head of software engineering, framed it against the old language: Apple had used Objective-C for twenty years and loved it, but had wondered what it could do “without the baggage of C”. The shorthand that stuck in the press was “Objective-C without the C”. Apple’s press release called it “a powerful new programming language for iOS and OS X” that “coexists with Objective-C code, so developers can easily integrate Swift into their existing apps.”

Hardly anyone outside the team had known. The announcement drew, by several accounts, the loudest cheer of the keynote, and it was followed by a run on documentation: The Swift Programming Language, released free on the iBooks Store the same day, was downloaded about 370,000 times in its first day. The WWDC conference app itself, updated that week, was the first publicly released app written in Swift.

Swift 1.0 shipped with Xcode 6 on 9 September 2014, and developers could submit Swift apps to the App Store once iOS 8 was out. In Stack Overflow’s 2015 developer survey Swift was voted the “most loved” language, and by the first quarter of 2018 it had overtaken Objective-C in measured popularity.

Safety by Design

Swift’s central decision was to move a set of common runtime crashes into the compiler.

  • Optionals. A Swift variable cannot hold nil unless its type says so (String? rather than String). Before using an optional value the programmer must unwrap it, with if let, guard let, a default via ??, or an explicit ! that crashes deliberately if the value is absent. Tony Hoare had called his 1965 invention of the null reference his “billion-dollar mistake”; Swift kept the concept but made the compiler track where it could occur.
  • Checked arithmetic and bounds. Integer overflow traps instead of wrapping silently, and array indexing is bounds-checked. Wrapping arithmetic exists, but under separate operators (&+).
  • Value types. Structs, enums and the standard collections (Array, Dictionary, String) are values, copied on assignment, with copy-on-write behind the scenes to avoid the cost. Two variables cannot accidentally share and mutate the same array, a frequent source of Objective-C bugs.
  • Enums with associated values and exhaustive switch. The compiler rejects a switch that forgets a case, a feature taken from the ML family of languages.
  • Type inference. Types are checked statically but rarely written out, so code stays short.
  • ARC instead of a tracing garbage collector. Memory is reclaimed deterministically, without collector pauses, which mattered on phones.
  • let and var. Immutability is the default habit; the compiler warns when a var is never mutated.

The safety had a cost the designers accepted openly. Swift’s type checker, which has to solve constraints across overloaded operators and literals, can be slow, and for years developers met the message that an expression was “too complex to be solved in reasonable time”. Compile times for large Swift projects remained a standing complaint long after the language itself had settled.

Three Years of Breaking Changes

Swift 1.0 was usable, not finished, and Apple said so by changing it. Swift 1.2 (April 2015) and Swift 2.0 (September 2015, with guard, defer and try/catch error handling) each required developers to run Xcode’s automatic migrator over their code. The biggest break came with Swift 3.0 in September 2016.

Swift 3 was the first release designed in public (see below), and its proposals were deliberately disruptive. Lattner’s own SE-0004 removed the C-style ++ and -- operators, asking “if we didn’t already have these, would we add them to Swift 3?” SE-0007 removed the C-style for loop. SE-0005, by Doug Gregor and Dave Abrahams, changed how every Objective-C API was imported into Swift, so that NSString’s stringByReplacingOccurrencesOfString:withString: became replacingOccurrences(of:with:). Developers called it the “Grand Renaming”. Nearly every line that touched Apple’s frameworks changed spelling, and large apps took weeks to migrate.

The churn was the price of fixing the language before it set. Swift 4 (September 2017) was the first release whose compiler also accepted most Swift 3 code, through a “Swift 3.2” compatibility mode, and from then on breaking changes became rare.

Open Source and Swift Evolution

On 3 December 2015 Apple published Swift’s compiler, standard library, debugger, package manager and core libraries on GitHub under the Apache 2.0 license with a runtime library exception, together with a port to Linux. Swift.org opened as the project’s home. “By making Swift open source the entire developer community can contribute to the programming language and help bring it to even more platforms,” Federighi said. Swift 2.2 in March 2016 was the first release with official Linux builds.

The same day Apple opened the Swift Evolution process: every change to the language goes through a numbered proposal, a public review thread and a decision by the core team. Proposals SE-0001 onwards are on GitHub with their rationale, which makes Swift one of the best-documented language designs in history. Apple retained the final say, and the core team was composed largely of Apple employees.

Apple also turned Swift into an education project. Swift Playgrounds, announced at WWDC on 13 June 2016 and released for the iPad on 13 September 2016, taught programming through puzzles aimed at “middle school students and up”, alongside the free Everyone Can Code curriculum. A Mac version followed in February 2020, and version 4.0 in December 2021 allowed whole SwiftUI apps to be built and submitted to the App Store from an iPad.

Lattner Leaves

On 10 January 2017 Lattner told the Swift Evolution mailing list that he was leaving Apple. He spent a few months as Tesla’s vice president of Autopilot software and joined Google in August 2017. Leadership of the Swift project passed to Ted Kremenek, who, Lattner wrote, “has actually been running the Swift team for quite some time.”

Lattner stayed on the Swift core team as an outside member until 2021. In February 2022 he explained publicly why he had left it. “The root cause of my decision to leave the core team is a toxic environment in the meetings themselves,” he wrote on the Swift forums; the trigger was a meeting in the summer of 2021 where he was “insulted and yelled at over WebEx (not for the first time, and not just one core team member).” He had raised it with leadership in the autumn and been told little would change. He had then tried to contribute through Swift Evolution alone, but quit when his “formal proposal review comments and concerns were ignored by the unilateral accepts.” He added that “design premises I care about (e.g. ‘simple things that compose’) don’t seem in vogue any more” and that Swift “certainly isn’t a community designed language”. His account was a reply in the thread where Kremenek had announced, on 20 February 2022, that the core team would hand day-to-day language design to a new Language Workgroup.

Binary Stability

Until 2019 every Swift app carried its own copy of the Swift runtime and standard library inside its bundle. The reason was technical: the binary interface (ABI), meaning the exact layout of types in memory, the calling conventions and the name mangling, was still changing, so code compiled with one Swift version could not call a library compiled with another. Every app paid for that duplicate copy in download size.

Swift 5.0, released on 25 March 2019, fixed the ABI on Apple platforms. The Swift runtime moved into Apple’s operating systems themselves (iOS 12.2, watchOS 5.2 and tvOS 12.2 were the first), and apps no longer had to embed it, which made them smaller and faster to launch. Swift 5.1 (September 2019) added module stability, which let vendors ship precompiled binary frameworks that keep working with later compilers. Both were prerequisites for what Apple announced the same summer.

SwiftUI

At WWDC in June 2019 Apple introduced SwiftUI, a declarative UI framework. Instead of creating view objects and mutating them in response to events, as UIKit and AppKit had done since NeXTSTEP, the programmer describes what the interface should look like for a given state, and the framework works out the changes. The model was familiar from web frameworks such as Facebook’s React, but SwiftUI used Swift-specific features to make it read like a configuration file: result builders, property wrappers such as @State, and opaque return types (some View), several of which were added to the language largely for this framework.

SwiftUI’s arrival marked a break deeper than the change of language. A Swift app written with UIKit in 2018 still followed the object design of NeXTSTEP from 1988. A SwiftUI app followed a design that had no Objective-C counterpart at all. UIKit did not go away: Apple’s own apps mixed the two, and SwiftUI’s early versions were criticized for missing controls and unpredictable layout behavior, but each WWDC since has extended it to more of the platform.

Concurrency and Swift 6

Swift’s next large addition attacked a different class of bugs. Swift 5.5 (September 2021) introduced async/await, structured concurrency with task groups, and actors, objects whose mutable state can only be touched by one task at a time. The compiler began checking which values could be safely sent between concurrent tasks (the Sendable protocol), first as warnings.

Swift 6 (September 2024) made those checks errors in a new, opt-in Swift 6 language mode, which the release notes describe as extending “Swift’s safety guarantees to prevent data races in concurrent code by diagnosing potential data races in your code as compiler errors.” In effect Swift claimed for concurrent code what Rust had claimed with its ownership system. The migration was hard. Large codebases produced hundreds of diagnostics, many involving Apple’s own frameworks that had not yet been annotated, and the following releases spent much of their effort on making the checks less noisy. Swift 6.2 (15 September 2025) added “approachable concurrency”, an option under which code runs on the main actor by default unless the programmer asks otherwise.

Swift 6 also showed how far the project had spread beyond the iPhone: it shipped a fully static SDK for Linux, a rewrite of the Foundation library in Swift for all platforms, a new testing library that runs on “all platforms that Swift officially supports, including all Apple platforms, Linux, and Windows”, and a preview of Embedded Swift, a subset that compiles to small standalone binaries for ARM and RISC-V microcontrollers. Windows support had been official since Swift 5.3 in 2020. In June 2024 the project moved its repositories from Apple’s GitHub organization to a new, neutral swiftlang organization, and on 24 October 2025 the community Android workgroup released the first preview of an official Swift SDK for Android, reporting that more than a quarter of the packages in the Swift Package Index already built for it.

Dead End

Swift was meant to be more than an Apple language, and the open-sourcing in 2015 with a Linux port was read as an invitation to the server and the scientific world. Three attempts to take it there ended without the result their backers hoped for.

Server-side Swift. IBM was the largest early ally. It released Kitura, a Swift web framework, in February 2016 and promoted Swift as a way for mobile developers to write their own back ends. On 17 December 2019 IBM’s Ian Partridge and Chris Bailey stood down from the Swift Server Work Group: “following a review by IBM of its open source priorities, it has been decided that they will not be continuing to work on Swift in 2020.” Bailey’s explanation was that “Swift … hasn’t represented the market opportunity on the server that we had hoped.” Server-side Swift survived through the community frameworks Vapor and Hummingbird, but it never became a general alternative to Java, Go or Node.js.

Swift for TensorFlow. At Google, Lattner unveiled Swift for TensorFlow at the TensorFlow Dev Summit in 2018. It built automatic differentiation into the language and promised to replace Python for machine learning with a compiled, type-checked language. Google archived the project in February 2021, a year after Lattner had left the company. A few pieces lived on, notably PythonKit for calling Python from Swift and work on differentiable programming that was proposed for Swift itself. Python’s ecosystem of libraries and notebooks proved more valuable to researchers than compile-time checking. Lattner drew his own conclusion: Mojo, the language his company Modular unveiled in May 2023, was presented as a superset of Python rather than a replacement for it.

Ladybird. In 2024 the independent Ladybird browser project, which was writing a new browser engine from scratch in C++, chose Swift as its memory-safe successor language after team members had tried several candidates. Swift’s bidirectional C++ interoperability, introduced in Swift 5.9 in 2023, was the deciding feature. It did not mature enough for a large codebase, and Swift’s tooling outside Apple’s platforms remained thin. On 17 February 2026 Andreas Kling closed the project’s issue tracking Swift blockers: “Closing this as we are no longer pursuing Swift adoption.” Ladybird moved to Rust instead, starting with an AI-assisted port of its JavaScript engine.

The pattern in all three is that Swift’s design, its tools and most of its paid developers were organized around Apple’s platforms, and adopters elsewhere ran into the gaps. On Apple’s own platforms the transition succeeded: within a few years Swift was the default for new code, Apple’s frameworks were redesigned around it, and Objective-C moved into maintenance. Objective-C itself still compiles in every version of Xcode, as do the C-based frameworks underneath it, four decades after Cox and Love bolted Smalltalk onto C.

📚 Sources