Swift By Rahul
August 7, 2026 · 9 min read ·

Swift Package Manager for iOS Development

As iOS developers, we constantly rely on external libraries and frameworks to accelerate development, implement complex features, and adhere to best practices. Managing these dependencies efficiently is crucial for maintaining a clean, scalable, and robust codebase. Enter Swift Package Manager (SPM), Apple's native solution for managing the distribution of Swift code.

SPM has evolved significantly since its inception, becoming a first-class citizen in Xcode and an indispensable tool for iOS, macOS, watchOS, and tvOS development. It not only simplifies integrating third-party packages but also empowers you to modularize your own projects into reusable Swift packages.

In this article, we'll dive deep into Swift Package Manager, covering how to add external dependencies, create your own packages, and leverage its advanced features to streamline your iOS development workflow.

Swift Package Manager as a central hub for dependencies Your iOS App Swift Package Manager Manages Package A Package B Package C

What is Swift Package Manager?

Swift Package Manager is a tool for managing the distribution of Swift code. It's integrated directly into the Swift build system and works across all Apple platforms. At its core, SPM enables you to:

  1. Declare Dependencies: Specify the external Swift packages your project relies on, typically by referencing their Git repository URLs and version requirements.
  2. Resolve Dependencies: SPM automatically fetches, builds, and links these packages into your project, ensuring all necessary transitive dependencies are also resolved.
  3. Create Packages: Define your own reusable modules as Swift packages, making them easy to share within your organization or with the broader Swift community.

Before SPM became widely adopted, iOS developers often relied on third-party dependency managers like CocoaPods or Carthage. While effective, these tools sometimes introduced additional complexity, build system quirks, or required separate configuration files. SPM's native integration with Xcode simplifies the entire process, making dependency management a much smoother experience.

Adding a Dependency to Your iOS Project

Integrating an external Swift package into your iOS project using SPM is straightforward with Xcode. Let's walk through an example using SwiftSoup, a popular library for parsing HTML documents.

  1. Open Your Xcode Project: Start by opening an existing iOS project in Xcode.
  2. Add Packages: Go to File > Add Packages... in the Xcode menu bar.
  3. Search or Enter URL: In the search bar that appears, you can either search for popular packages on GitHub or paste the URL of the package's Git repository. For SwiftSoup, you can paste https://github.com/scinfu/SwiftSoup.git.
  4. Choose Dependency Rule: After Xcode fetches the package, you'll see options to specify the dependency rule:
    • Up to Next Major Version: (e.g., 1.7.0 to 2.0.0) Recommended for most cases, allowing minor updates without breaking changes.
    • Up to Next Minor Version: (e.g., 1.7.0 to 1.8.0) More restrictive, only allowing bug fixes and non-breaking feature additions.
    • Exact Version: (e.g., 1.7.5) Locks to a specific version, providing maximum stability but requiring manual updates.
    • Branch: Follows a specific branch (e.g., main). Useful for development versions.
    • Commit: Locks to a specific commit hash. For SwiftSoup, let's choose "Up to Next Major Version" with 1.7.5. 5. Add Package: Click "Add Package". Xcode will then fetch the package, resolve its dependencies, and integrate it into your project. You'll see the package listed under "Package Dependencies" in your project navigator.

Now, you can use SwiftSoup in your code. For instance, to parse an HTML string:

import SwiftSoup // Don't forget to import!

func parseHTMLContent() {
    let html = """
    <html>
        <head>
            <title>My Page</title>
        </head>
        <body>
            <h1>Welcome</h1>
            <p class="intro">This is an introduction paragraph.</p>
            <a href="https://www.apple.com">Apple</a>
        </body>
    </html>
    """

    do {
        let doc: Document = try SwiftSoup.parse(html)

        // Get the title
        let title = try doc.title()
        print("Page Title: \(title)") // Output: Page Title: My Page

        // Get the text from the h1 tag
        let h1Text = try doc.select("h1").first()?.text()
        print("H1 Text: \(h1Text ?? "N/A")") // Output: H1 Text: Welcome

        // Get the text from the paragraph with class "intro"
        let introParagraph = try doc.select("p.intro").first()?.text()
        print("Intro Paragraph: \(introParagraph ?? "N/A")") // Output: Intro Paragraph: This is an introduction paragraph.

        // Get the href of the link
        let linkHref = try doc.select("a").first()?.attr("href")
        print("Link Href: \(linkHref ?? "N/A")") // Output: Link Href: https://www.apple.com

    } catch Exception.Error(_, let message) {
        print(message)
    } catch {
        print("error")
    }
}

// Call the function, e.g., from a viewDidLoad or a button action
// parseHTMLContent()

Creating Your Own Swift Package

One of SPM's most powerful features is the ability to create your own Swift packages. This is invaluable for modularizing large applications, sharing common code across multiple projects, or building open-source libraries.

Let's create a simple utility package that provides extensions for String.

  1. Create a New Package: In Xcode, go to File > New > Package....
  2. Name and Location: Give your package a name (e.g., MyStringUtilities) and choose a location. Click "Create".

Xcode will generate a basic package structure:

MyStringUtilities/
├── Sources/
│   └── MyStringUtilities/
│       └── MyStringUtilities.swift
├── Tests/
│   └── MyStringUtilitiesTests/
│       └── MyStringUtilitiesTests.swift
└── Package.swift
  • Sources: Contains your actual Swift code. Each subdirectory here represents a "target" in your package.
  • Tests: Contains unit tests for your package.
  • Package.swift: The manifest file that defines your package's structure, products, targets, and dependencies.

Open MyStringUtilities.swift and add some useful String extensions:

// Sources/MyStringUtilities/MyStringUtilities.swift

import Foundation

public extension String {
    /// Returns the string with its first letter capitalized.
    var capitalizedFirstLetter: String {
        guard !isEmpty else { return "" }
        return prefix(1).uppercased() + dropFirst()
    }

    /// Returns a new string with all occurrences of a specified substring removed.
    func removingOccurrences(of substring: String) -> String {
        return replacingOccurrences(of: substring, with: "")
    }
}

Now, let's look at the Package.swift file. It's a crucial part of your package, defining how it behaves.

// swift-tools-version: 5.9
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "MyStringUtilities", // The name of your package
    products: [
        // Products define the executables and libraries a package produces, making them visible to other packages.
        .library(
            name: "MyStringUtilities",
            targets: ["MyStringUtilities"]),
    ],
    targets: [
        // Targets are the basic building blocks of a package, defining a module or a test suite.
        // Targets can depend on other targets in this package, and on products in packages this package depends on.
        .target(
            name: "MyStringUtilities"), // This is our source code target
        .testTarget(
            name: "MyStringUtilitiesTests",
            dependencies: ["MyStringUtilities"]), // This is our test target, depending on our source target
    ]
)
  • swift-tools-version: Specifies the minimum Swift tools version required.
  • name: The name of your package.
  • products: Defines what your package exposes. A .library product makes the code available for other Swift projects to import.
  • targets: Defines the actual code modules within your package. A .target contains source code, and a .testTarget contains tests for a specific target.

Using Your Local Package in an iOS App

To use MyStringUtilities in an existing iOS app:

  1. Add Local Package: In your iOS app's Xcode project, go to File > Add Packages....
  2. Add Local: Instead of pasting a URL, click "Add Local..." and navigate to the directory where you saved your MyStringUtilities package.
  3. Add Package: Select the Package.swift file and click "Add Package".

Now, you can import and use your custom extensions:

import MyStringUtilities // Import your custom package

func demonstrateStringUtilities() {
    let originalString = "hello swift by rahul"
    print(originalString.capitalizedFirstLetter) // Output: Hello swift by rahul

    let messyString = "hello---world---"
    print(messyString.removingOccurrences(of: "---")) // Output: helloworld
}

// demonstrateStringUtilities()

Advanced SPM Concepts

Understanding the Package.swift manifest in more detail allows for powerful configuration.

Structure of Package.swift manifest Package.swift Products Targets Dependencies Sources Resources Target Dependencies

Package Dependencies

The dependencies array within Package defines external packages your package relies on.

let package = Package(
    // ...
    dependencies: [
        .package(url: "https://github.com/scinfu/SwiftSoup.git", .upToNextMajor(from: "1.7.5")),
        // Add other external packages here
    ],
    targets: [
        .target(
            name: "MyStringUtilities",
            dependencies: [
                // If MyStringUtilities target needed SwiftSoup, you'd add it here
                // .product(name: "SwiftSoup", package: "SwiftSoup")
            ]),
        // ...
    ]
)

Notice the .product(name: "SwiftSoup", package: "SwiftSoup") syntax. When a target depends on a product from an external package, you specify both the product name and the package name. If it's a product from the same package, you just use the product name (which typically matches the target name).

Resources

If your package needs to bundle assets like images, JSON files, or localized strings, you can declare them as resources.

.target(
    name: "MyPackage",
    resources: [.process("Resources")] // Processes all files in the "Resources" directory
)

You would create a Resources directory inside your target's folder (e.g., Sources/MyPackage/Resources). You can then access these resources using Bundle.module:

// Example: Loading a JSON file from Resources
if let url = Bundle.module.url(forResource: "data", withExtension: "json") {
    // Load data from url
}

Conditional Dependencies

You can make dependencies platform-specific using .when():

.target(
    name: "MyPackage",
    dependencies: [
        .product(name: "SomeMacOSOnlyFramework", package: "SomeMacOSOnlyFramework", condition: .when(platforms: [.macOS])),
        .product(name: "SomeIOSExtension", package: "SomeIOSExtension", condition: .when(platforms: [.iOS]))
    ]
)

This is particularly useful for packages that support multiple platforms but rely on platform-specific APIs or frameworks.

Best Practices for Using SPM

  1. Semantic Versioning: Always specify your package dependencies using semantic versioning (e.g., 1.2.3). This helps prevent unexpected breaking changes. Prefer .upToNextMajor for external dependencies to balance stability and updates.
  2. Keep Dependencies Updated: Regularly update your packages (File > Packages > Update to Latest Package Versions) to get bug fixes, performance improvements, and security patches.
  3. Modular Design: Use packages to enforce modularity within your own codebase. Break down large apps into smaller, independent packages (e.g., UI components, network layer, data models). This improves code organization, reusability, and build times.
  4. Avoid Dependency Hell: Be mindful of the number of dependencies you add. More dependencies mean larger app size, potentially slower build times, and a higher risk of conflicts.
  5. Test Your Packages: Always include comprehensive unit tests for your custom packages. This ensures their reliability and makes refactoring safer.

Comparison: Remote vs. Local Packages

┌──────────────────┐               ┌──────────────────┐
│   Remote Package │               │   Local Package  │
│ (e.g., SwiftSoup)│               │ (e.g., MyStringUtils)│
├──────────────────┤               ├──────────────────┤
│ - Defined by URL │               │ - Defined by FilePath│
│ - Version control│               │ - Direct access  │
│ - Publicly shared│               │ - For monorepos  │
│ - Requires fetch │               │ - Fast iteration │
└──────────────────┘               └──────────────────┘
         ▲                                   ▲
         │                                   │
         └───────────── Swift Package Manager ─────────────┘
                                   ▲
                                   │
                           ┌──────────────────┐
                           │   Your iOS App   │
                           └──────────────────┘

Summary

Swift Package Manager is an essential tool for modern iOS development. It provides a robust, integrated, and efficient way to manage external dependencies and modularize your own code. By embracing SPM, you can build more maintainable, scalable, and organized applications, focusing more on developing features and less on managing your project's infrastructure.

Happy Swifting!

Tagged: