Scipio Documentation

Unlike the CLI version which is limited to Project or Local disk caches, ScipioKit allows you to use remote storage (like Amazon S3 via ScipioS3Storage) or implement your own by conforming to the FrameworkCacheStorage protocol.

Cache Actors

When defining a FrameworkCachePolicy, you can specify which actors are associated with the storage:

• consumer: An actor that fetches cache from the storage.
• producer: An actor that attempts to save build artifacts to the storage.

Multiple Cache Policies

You can chain multiple policies. If a framework is not found in the first storage (e.g., S3), Scipio will attempt to fetch it from the next one (e.g., .localDisk). If it is not found anywhere, it will be built and then cached in the storages associated with the producer actor.

import ScipioS3Storage

// Using S3 with a consumer actor, and falling back to local disk
let s3Storage: some FrameworkCacheStorage = ScipioS3Storage.S3Storage(config: ...)
let runner = Runner(
    mode: .prepareDependencies,
    options: .init(
        baseBuildOptions: .init(
            buildConfiguration: .release,
            isSimulatorSupported: true
        ),
        cachePolicies: [
            .init(storage: s3Storage, actors: [.consumer]),
            .localDisk,
        ]
    )
)

While the Scipio CLI is suitable for simple tasks, ScipioKit allows you to build complex build pipelines using Swift code. This enables advanced configurations such as passing custom C/Linker/Swift flags, overriding build options per target, using remote cache storage (like Amazon S3), and implementing custom logic or user interfaces.

To implement a build script, create an executable Swift package, add ScipioKit as a dependency, and use the Runner class to execute the build process.

import Foundation
import ScipioKit

@main
struct EntryPoint {
    private static let myPackageDirectory = URL(fileURLWithPath: "/path/to/MyPackage")

    static func main() async throws {
        let runner = Runner(
            mode: .prepareDependencies,
            options: .init(
                baseBuildOptions: .init(
                    buildConfiguration: .release,
                    isSimulatorSupported: true
                )
            )
        )

        try await runner.run(
            packageDirectory: myPackageDirectory,
            frameworkOutputDir: .default
        )
    }
}

Scipio's prepare mode allows you to build all dependencies defined in a Swift Package manifest as XCFrameworks. This is useful for pre-building dependencies to speed up build times or to manage binary dependencies in an Xcode project.

Workflow

1. Create a Dependency Package: Create a new Swift Package (ideally in the same directory as your Xcode project) to act as a manifest for your dependencies.

   mkdir MyAppDependencies
   cd MyAppDependencies
   swift package init

2. Configure Package.swift: Edit the manifest to include your required dependencies.

   • Platforms: You must specify platforms (e.g., .iOS(.v14)) because Scipio uses this to determine which SDKs to build for.
   • Targets: You must depend on all desired products in a single primary target. Declare all other targets as dependencies of this first target.

3. Run Scipio: Execute the prepare command pointing to your package directory.

   scipio prepare path/to/MyAppDependencies

By default, all generated XCFrameworks are placed in [PackageRoot]/XCFramework.

$ scipio prepare path/to/MyAppDependencies