Swift package export setup

In the following example, the shared code of a Kotlin Multiplatform project is stored locally in the shared module. If your project is structured differently, substitute "shared" in code and path examples with your module's name.

To set up the publishing of an XCFramework:

1. Update your shared/build.gradle.kts configuration file with the XCFramework call in the iOS targets list:

   import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFramework
   
   kotlin {
       // Other Kotlin Multiplatform targets
       // ...
       // Name of the module to be imported in the consumer project
       val xcframeworkName = "Shared"
       val xcf = XCFramework(xcframeworkName)
   
       listOf(
           iosX64(),
           iosArm64(),
           iosSimulatorArm64(),
       ).forEach {
           it.binaries.framework {
               baseName = xcframeworkName
   
               // Specify CFBundleIdentifier to uniquely identify the framework
               binaryOption("bundleId", "org.example.${xcframeworkName}")
               xcf.add(this)
               isStatic = true
           }
       }
       //...
   }

2. Run the Gradle task to create the framework:

   ./gradlew :shared:assembleSharedXCFramework

   The resulting framework will be created as the shared/build/XCFrameworks/release/Shared.xcframework folder in your project directory.

   tip

   In case you work with a Compose Multiplatform project, use the following Gradle task:

   ./gradlew :composeApp:assembleSharedXCFramework

   You can then find the resulting framework in the composeApp/build/XCFrameworks/release/Shared.xcframework folder.

1. Compress the Shared.xcframework folder in a ZIP file and calculate the checksum for the resulting archive, for example:

   swift package compute-checksum Shared.xcframework.zip

2. Upload the ZIP file to the file storage of your choice. The file should be accessible by a direct link. For example, here's how you can do it using releases in GitHub:

   Upload to a GitHub release

   1. Go to GitHub and log in to your account.

   2. Navigate to the repository where you want to create a release.

   3. In the Releases section on the right, click the Create a new release link.

   4. Fill in the release information, add or create a new tag, specify the release title and write a description.

   5. Upload the ZIP file with the XCFramework through the Attach binaries by dropping them here or selecting them field at the bottom:

      

   6. Click Publish release.

   7. Under the Assets section of the release, right-click on the ZIP file and select Copy link address or a similar option in your browser:

      

3. [Recommended] Check that the link works and that the file can be downloaded. In the terminal, run the following command:

   curl <downloadable link to the uploaded XCFramework ZIP file>

4. Choose any directory and locally create a Package.swift file with the following code:

   // swift-tools-version:5.3
   import PackageDescription
   
   let package = Package(
      name: "Shared",
      platforms: [
        .iOS(.v14),
      ],
      products: [
         .library(name: "Shared", targets: ["Shared"])
      ],
      targets: [
         .binaryTarget(
            name: "Shared",
            url: "<link to the uploaded XCFramework ZIP file>",
            checksum:"<checksum calculated for the ZIP file>")
      ]
   )

5. In the url field, specify the link to your ZIP archive with the XCFramework.

6. [Recommended] To validate the resulting manifest, you can run the following shell command in the directory with the Package.swift file:

   swift package reset && swift package show-dependencies --format json

   The output will describe any errors found or show the successful download and parsing result if the manifest is correct.

7. Push the Package.swift file to your remote repository. Make sure to create and push a Git tag with the semantic version of the package.

Now that both files are accessible, you can add the dependency on the package you created to an existing client iOS project or create a new project. To add the package dependency:

1. In Xcode, choose File | Add Package Dependencies.

2. In the search field, enter the URL of the Git repository with the Package.swift file inside:

   

3. Press the Add package button, then select products and corresponding targets for the package.

   tip

   If you're making a Swift package, the dialog will be different. In this case, press the Copy package button. This will put a .package line in your clipboard. Paste this line into the Package.Dependency block of your own Package.swift file, and add the necessary product to the appropriate Target.Dependency block.

To check that everything is set up correctly, test the import in Xcode:

1. In your project, navigate to your UI view file, for example, ContentView.swift.

2. Replace the code with the following snippet:

   import SwiftUI
   import Shared
   
   struct ContentView: View {
       var body: some View {
           VStack {
               Image(systemName: "globe")
                   .imageScale(.large)
                   .foregroundStyle(.tint)
               Text("Hello, world! \(Shared.Platform_iosKt.getPlatform().name)")
           }
           .padding()
       }
   }
   
   #Preview {
       ContentView()
   }

   Here, you import the Shared XCFramework and then use it to obtain the platform name in the Text field.

3. Ensure that the preview is updated with the new text.