As we begin 2022, it has been almost 20 years since Apple released Xcode to developers as the predominant way to create Mac apps. This revolutionary integrated development environment, or IDE, has morphed into the entry point for building every type of app for all five current Apple platforms. Xcode is both loved and loathed in developer circles, but — love it or hate it — it is used by hundreds of thousands of developers worldwide every day to build software for iOS, iPadOS, macOS, tvOS, and watchOS.
IDEs’ merging of text editor, debugger, and packaging systems is what makes them so useful, and they have lowered the barrier of entry for software creators. IDEs were not new when Apple came along and revolutionized the software on the Mac. In fact, the first IDE, Maestro I, was developed in the 1970s to allow better integration between the software components used to prepare punch cards.
Onlookers and even users of Xcode often take for granted where the software came from, how it began, and how it has been iterated on throughout its lifetime. This is where we begin with today’s story of Xcode: with a look back on the history and milestone features of this IDE and its decades-long journey of being used to craft some of the most utilized software on the planet.
Let the nostalgia rain over you as we take a look back and reminisce about the history of Xcode from its lowly beginnings…
Every hero has an origin story
To appreciate the lineage of Xcode, hop into your time machine, set your modem to dial up to AOL, and get yourself some hair spray, because we’re headed back to the year 1992.
This is when NeXT released Project Builder, a first-of-its-kind IDE that was shipped alongside NeXTSTEP OS 3.0. Project Builder was revolutionary because it used a new programming language called Objective-C (based on Smalltalk) and a UI development paradigm using a WYSIWYG style UI editor called Interface Builder that improved the speed at which applications could be built for NeXT, making IT and universities drool over the possibilities.
By the mid ’90s, Apple was in dire straits financially. Mac OS was a mess, developers and users were leaving the platform in droves, and only the faithful stuck by the products. This is when Apple started searching for a modern operating system replacement for Mac OS. After a lengthy search, it purchased NeXT and NeXTSTEP to be the basis of what would eventually be called Mac OS X. The purchase also positioned the company for the return of Steve Jobs as the CEO and its growth into the goliath it is today.
Mac OS X Tiger install DVD with Xcode 2 included.
As a part of Mac OS X, Project Builder was rebuilt from scratch to build Mac apps and first included with Mac OS X Cheetah (10.0) Developer Preview 4. The biggest thing? Apple gave the IDE away for free.
Yes, that’s right. Free.
This was a revolutionary idea, and Apple put itself in direct competition with the commercially available IDEs like CodeWarrior that developers were using at the time to build apps for the Mac. It would take a few years, but Project Builder (and its successor, Xcode) would become the dominant IDE for developers building apps on the Mac — especially as Apple began developing new platforms like the iPhone and essentially locked developers into using Xcode for building apps for those platforms.
Interface Builder as it appeared in Project Builder on NeXTSTEP in the early to mid ’90s.
Project Builder (commonly known as PBX for the Mac OS X release) lived a fairly short life until it was tweaked and rebranded as Xcode beginning in 2003 with Mac OS X Jaguar (10.3). It had many of the same features you find in Xcode, including the file formats (though it has changed slightly over the years) and Interface Builder (though a standalone app at the time) to create XIB files to house user interfaces.
Project Builder as it appeared in a Mac OS X Cheetah beta release. Image via ArsTechnica.
In the days before large downloads, Apple included these developer tools on the Mac OS X install discs or as a part of a separate set of discs labeled “Developer Tools.” When you bought a new Mac in this era, you would also receive these tools, which were useful if you were a developer or an aspiring developer.
This was a brilliant marketing move on Apple’s part, because it enticed users to learn about developing software for the new operating system and also made it easier to get up to speed doing it. This was an era where most software development kits cost thousands of dollars, which was true even years later on platforms like Windows. This marketing no doubt led to many users learning to become developers for the Mac platform by installing this freely available tool.
Xcode comes of age
The rebranding of Project Builder to Xcode was the beginning of a long history of changes. Back in those days, many things we take for granted today weren’t available to developers. There was no code completion, no inline documentation, and no integration with GitHub — you typed, built, and hoped for the best. Code completion would come with Xcode 1.5 in August 2004, though, making the lives of developers forever easier.
Xcode 2.0 window showing the interactive class model representation that could be used to navigate through the codebase.
In 2005, in the days of Mac OS X Tiger (10.4), Apple was on an innovation roll, and the Mac product team was aiming for the stratosphere in terms of quality, changes, and getting developers onto the platform. One of these changes was the introduction of Xcode 2, a major release that brought about Quartz Composer (a utility that let developers string together animations quickly and easily) and the Apple Reference Library (to quickly look up documentation) — which is still in Xcode today.
One of the biggest changes in 2005 was Apple’s announcement that they would be leaving behind PowerPC and moving to Intel processors beginning in 2006 — a change that was enabled thanks to Xcode 2.1, which brought about the ability to build universal binary apps that could run on both processor types and allowed Mac developers to write truly processor-independent code. During this iteration, Apple also added some powerhouse features including unit testing for targets, conditional breakpoints, and watchpoints.
Mac OS X Leopard (10.5) ushered in even more notable Xcode improvements that we use to this day. One of the features Xcode 3 brought was the DTrace debugging utility (now called Instruments) that allowed developers to hone their apps for better performance and to watch for memory leaks and other issues. This version of Xcode also added the Objective-C 2.0 language changes and garbage collection, easy code refactoring, and the ability to build apps not only for PowerPC and Intel but also for 32-bit and 64-bit architectures. This allowed Xcode to quickly become the power developer’s toolkit and an IDE that was really required to keep track of the fast pace that Apple set for the Mac.
In 2007, everything changed as the world stared eagerly into the face of Apple’s newest platform: iPhone. It was a mobile experience like nothing that had been seen before, and developers were itching to get their hands on the device and to be able to build apps. Still, it wasn’t until 2008 that Xcode 3.1 would finally allow developers to target not only Mac OS X but also iPhone OS 2.0 using the iPhone SDK.
This was another groundbreaking step for Apple: No other company offered an IDE that would allow developers to create apps for both their main platform and a mobile platform using the same toolchain. Desktop-class mobile software had never even been thought about before due to software and hardware limitations, but Apple had done it, and soon the floodgates would open.
Xcode 3 continued to receive regular updates through the era of Mac OS X Snow Leopard (10.6), adding features such as iPhone OS 3.0 support. Java support was deprecated, and there was a change in the distribution model of Xcode: Developers would have to register on Apple’s website to download the IDE beginning with Xcode 3.2.6, putting an end to Apple shipping discs with each Mac purchase.
Xcode’s continued evolution
Xcode 4 was a major turning point in Xcode’s history, and the successive improvements were all built on the changes made during this era.
In 2010, Apple took the development community by surprise when it announced Xcode 4, a ground-up rewrite of the interface that merged two major development apps, Interface Builder and Xcode, into a single app. This merger meant that opening XIBs would no longer require opening Interface Builder separately.
Xcode 4 also dropped support for PowerPC, dropped support for GCC compiler in favor of a new compiler called LLVM, began shipping as a single application bundle called Xcode.app, and no longer included installation of the various other utilities that had previously been installed with the IDE. Apple also changed the distribution model again with the introduction of the Mac App Store: Xcode 4.0 was only made available to registered developers paying the $99 developer fee or a $4.99 one-time fee on the Mac App Store. This change was later reverted with Xcode 4.1, making the app once again freely available on the Mac App Store and to developers with free Apple Developer registrations.
Xcode 4.2 was released in 2011 with iOS 5, adding support for storyboards and ARC (automatic reference counting), both paradigm shifts for many developers used to working with XIBs for interface element placement and manual memory management. At the time, storyboards were an iOS-only feature, but they would eventually make their way over to the Mac. The last version of Xcode 4, version 4.6, was released in 2013 alongside the iOS 6.1 SDK, marking the end of the nearly four-year period that Apple had iterated over Xcode 4.
Xcode versions 5-9 had fewer groundbreaking changes than Xcode 4. They mostly added minor UI tweaks, but there were some notable features:
Xcode 5 showing the dual-pane storyboard editor.
Xcode 5, released June 10, 2013 — Support for 64-bit ARM architectures for iOS devices, removal of garbage collection binaries for Mac targets in 5.1.
Xcode 6 showing the AutoLayout constraints editor in a storyboard.
Xcode 6, released June 2, 2014 — Introduction of the Swift programming language, and Playgrounds support for quickly iterating over Swift code.
Xcode 7 showing the 3D scene editor enabled with SceneKit.
Xcode 7, released June 8, 2015 — Support for the Swift 2.0 language updates, introduction of Metal, and the ability to deploy to iOS devices without a developer account.
Xcode 8 showing the visual debugger.
Xcode 8, released June 13, 2016 — Support for Swift 3.0 language updates and new SDKs for Mac and iOS device updates.
Xcode 9 showing the new editor “multiple replace” renaming tool.
Xcode 9, released June 5, 2017 — Support for Swift 4.0 language updates, Metal 2, and wireless debugging of iOS and tvOS devices.
Xcode 10 showing dark mode and editor changes.
With Xcode 10, Apple once again wanted to improve on some of the key features of the app. On June 14, 2018, the new version was released alongside macOS Mojave to developers at WWDC. This version of Xcode added support for Bitbucket, GitLab, and GitHub for source management as well as the ability to train CoreML models. It also made major, ground-up changes to the editor and build systems, allowing projects to build faster. The editor changes also paved the way for new autocompletion features and official Xcode plugins; however, developers complained of frequent editor and autocompletion crashes throughout Xcode 10’s lifecycle.
In recent years, Apple has continued to iterate over Xcode, ensuring that it remains the powerhouse that developers create apps with, designers tweak color palettes and UI elements with, and students learn to code with every day.
Xcode 11, released June 3, 2019, added support for Swift 5.1 and the newly released SwiftUI framework, letting developers experience a new way to lay out their Swift apps for all Apple platforms. It also added support for building macOS apps using iPad-compatible binaries through Catalyst and integration for the new Swift Package Manager — a fully Apple-sanctioned way to add dependencies and manage them with ease.
Xcode 13.0 running SwiftUI code with the visual inspector opened for debugging.
Xcode 12 and 13 have remained relatively unchanged, with Xcode 13 (released in 2021) receiving some slight UI tweaks and improvements. The main addition was the release of the new Swift Concurrency model in, and overall improvements to, the version control system, allowing users to view and approve pull requests right from Xcode for supported version control systems.
Today and into the future
As our trip down Xcode memory lane shows, Apple has continuously updated and improved it, adding developer-friendly features, removing unused features, and doing a great job of maintaining an IDE that is vital to its developer community.
Today, Xcode is still the predominant IDE for building apps, frameworks, and services for the Mac, iPhone, iPad, Apple Watch, and Apple TV platforms, and it will likely continue to be the main way we build apps going forward, even as Apple unveils new platforms.
The form factor of Xcode is shifting, however. The end of 2021 saw the release of Swift Playgrounds 4 for iPad, a fully functional IDE that can build an app from start to finish right inside iPadOS. Is it Xcode? Well, no, it doesn’t have all the same features. Does it have a subset of the features of Xcode, and can you ship an app with it? Yes. So it’s a different form factor of Xcode, but it produces the same end result.
Swift Playgrounds 4 running on macOS and iPadOS, sharing the same codebase for the same app. Apps built with Swift Playgrounds 4 on iPadOS can be run and delivered to the App Store for publication.
Files created in Swift Playgrounds can also be imported back into the full version of Xcode on the Mac to continue development, making Swift Playgrounds for iPad a great portable solution that brings the core features of Xcode to a new platform.
As platforms evolve and their needs change, Apple will likely follow this pattern when it comes to the Xcode IDE: integrating platform-specific features into Swift Playgrounds (or whatever comes next) and allowing developers to develop apps for a particular platform on the platform itself. If so, the company will be moving the boundary between gadgets and computers, since many consider the definition of a computer to be the ability to develop software for the platform you’re using on the platform itself.
So the next time that you open up Xcode to crank out a small bug fix, build the next billion-dollar app idea, or learn more about developing for iOS, remember that every app has a history — and we’re all writing it one line of code at a time.
