Download Center
All can be downloaded from here. Make sure you select the right platform.
Static Build Version 1.0.0 (Updated July 2024)
Documentation (Updated July 2024)
Static Version 1.0.0 (Updated July 2024)
Documentation (Updated July 2024)
Make sure you got the proper license before packaging your app for Apple distribution.
In the meantime, feel free to use it for free without limitation within XCode.
What is a XCFramework package for XCode ?
An XCFramework is a type of package introduced by Apple that allows developers to bundle multiple versions of a framework into a single distributable unit. This is particularly useful for supporting various platforms and architectures, such as iOS, macOS, watchOS, and tvOS, as well as different device types (e.g., simulator and physical device).
Here’s how it works:
- Multi-Platform Support: An XCFramework can include binaries for different Apple platforms, enabling you to distribute a single framework that works across iOS, macOS, watchOS, and tvOS without needing separate packages for each platform.
- Multi-Architecture Support: It can also contain binaries for different architectures, such as ARM64 (used by physical iOS devices) and x86_64 (used by iOS simulators on Intel-based Macs). This means that with an XCFramework, you can easily provide compatibility with both simulator and device builds.
- Easy Distribution: XCFrameworks simplify the distribution of your frameworks to other developers or teams. Instead of providing different versions of a framework for different environments, you can package them all together in one XCFramework, making it easier for developers to integrate into their projects.
- Compatibility: XCFrameworks are compatible with Xcode 11 and later, making them a modern and standardized way to distribute reusable code libraries across Apple's ecosystem.
Overall, XCFrameworks provide a convenient and powerful way to distribute frameworks that need to support multiple platforms and architectures, simplifying the developer experience and ensuring broader compatibility across Apple devices and environments.
How to install a XCFramework package in your XCode project ?
What is the difference between Static and Dynamic Frameworks ?
In Xcode, the main difference between a "static framework" and a "dynamic framework" lies in how they are linked to your application and their behavior at runtime.
Static Framework:
- Linking: A static framework is linked at compile time. This means that all the code and resources from the framework are copied into the final executable of your app. Once the app is compiled, the framework is no longer needed.
- Size: Since the code is embedded into the executable, the app's size can increase because of the inclusion of the static framework's code.
- Performance: Static frameworks generally offer faster startup times since there is no dynamic linking process at runtime.
- Duplication: If multiple apps or targets use the same static framework, the code gets duplicated in each app or target, increasing the overall disk usage.
Dynamic Framework:
- Linking: A dynamic framework is linked at runtime. This means that the framework’s code is not included in the final executable. Instead, the framework is loaded into memory when the app launches.
- Size: The app's initial binary size is smaller because the framework's code is not included. However, the framework needs to be bundled with the app, so the total size of the app bundle may not be significantly reduced.
- Performance: Dynamic frameworks might have a slightly slower startup time because the dynamic linker has to load and link the framework when the app starts.
- Shared Use: If multiple apps or targets use the same dynamic framework, they can share the framework's code at runtime, potentially reducing overall memory usage.
When to Use Each:
- Static Framework: Preferable when you need the framework code to be included directly in your binary, and you want faster app startup times.
- Dynamic Framework: Useful when you want to share code between multiple apps or targets, or when you want to reduce the size of the main executable.
In general, dynamic frameworks are more flexible and are the default choice for most modern iOS and macOS apps. However, static frameworks can still be useful in certain situations where performance and binary size are critical.