How to create, develop, and distribute iOS Static Frameworks quickly and efficiently
Objective-C Shell
Switch branches/tags
Nothing to show
Pull request Compare This branch is 1 commit ahead, 42 commits behind jverkoey:master.
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


Building a static iOS framework is a pain in the ass. There are a variety of existing solutions already and each one has its own disadvantages. Presented here is a solution that meets all of the following constraints while having no deal-breaking disadvantages.

  • Fast iterative compilation times (up to 3x faster than some solutions!).
  • Easy distribution and packaging.
  • No modifications to Xcode.
  • No trickery with fake bundle targets and the likes.
  • Simple set-up for third-parties.
  • Support for building the framework as a dependent target (i.e. modifying source in the framework and building an app will automatically rebuild the framework and relink as expected).
  • Works with the latest version of Xcode

Shameless plug: if you appreciate high-speed iOS development, check out Nimbus, the iOS framework whose growth is bounded by its documentation.

Creative Commons License
This work is licensed under a Creative Commons Attribution 3.0 Unported License.

Table of Contents

Existing Solutions ==================

Presented below are a few of the most popular solutions for building static iOS frameworks and the reasons why they should be avoided.

Note: Though the tone below is largely critical, credit is owed to those who pioneered these solutions. Much of the proposed solution is based off the work that these amazingly generous people have donated to the ether. Thanks!



Major problems

  • Slow iterative build times
  • Has to modify Xcode for "Real" frameworks
  • Can't properly add framework as a dependent target for "Fake" frameworks
  • No adequate solution for resource loading


This project provides two solutions: "fake" frameworks and "real" frameworks.

A fake framework is a bundle target with a .framework extension and some post-build scripts to generate the fat library for the .framework.

A real framework modifies the Xcode installation and generates a true .framework target. Real frameworks also use post-build scripts to generate the fat library.

Problems with Fake Frameworks

The problem with a fake framework is that you can't link to the framework as a dependent target. You can "trick" Xcode into linking to the framework by using the -framework flag in your LD_FLAGS, but changes to the framework will not be reflected in iterative builds. This requires that you clean build every time you modify the framework, or make a trivial modification to the application itself in order for it to forcefully relink to the new .framework. This bug is discussed here.

Example warning when you attempt to link to the .framework target:

warning: skipping file
(unexpected file type 'wrapper.cfbundle' in Frameworks & Libraries build phase)

Problems with Real Frameworks

To use real frameworks you need to modify your Xcode installation. This is simply not scalable when you want to work with a team of people. If you use a build farm this problem becomes even worse because it may not be possible to modify the Xcode installations on the build servers.

Problems with Both Fake and Real Frameworks

In both frameworks there is a post-build step that builds the "inverse" platform. For example, if you're building the framework for i386, the post-build step will build the framework for armv6/armv7 and then smush the libraries together into one fat binary within the framework. The problem with this is that it triples the build time of the framework. Make one change to a .m file and suddenly you're rebuilding it for three platforms. Change a PCH and your project will effectively perform three clean builds. This is simply not ok from a productivity standpoint.

There is also the problem of distributing resources with the .framework. Both the fake and real frameworks include an "embeddedframework" which is meant to be copied into the application. This results in the .framework binary being distributed with the application! Alternatively we could ask developers to only copy what's in the resources folder to their app, but this is complicated and requires we namespace our resource file names to avoid naming conflicts.

db-in's solution ("Fake" frameworks)


Major problems

  • Slow iterative build times
  • Can't properly add framework as a dependent target
  • No adequate solution for resource loading (recommends a remarkably bad solution)


db-in's solution is roughly identical to kstenerud's solution of using a bundle target to generate a fake framework. This has the same disadvantages as outlined above so I won't repeat myself.

There is, however, a specific deal-breaker with the recommendations in this blog post: resources. Db-in recommends copying the .framework into your application as a resource bundle; this is NOT OK. This will end up copying not just the resources from your framework, but also the fat binary of the framework! Doing this will inflate the size of your application by several megabytes more than it should be because you're shipping off a fat binary with your application.

And so without further ado...

How to Create a Static Framework for iOS ========================================

There are a few constraints that we want to satisfy when building a .framework:

  • Fast iterative builds when developing the framework. We may have a simple application that has the .framework as a dependency and we want to quickly iterate on development of the .framework.
  • Infrequent distribution builds of the .framework.
  • Resource distribution should be intuitive and not bloat the application.
  • Setup for third-party developers using the .framework should be easy.

I believe that the solution I will outline below satisfies each of these constraints. I will outline how to build a .framework project from scratch so that you can apply these steps to an existing project if you so desire. I will also include project templates for easily creating a .framework.

Overview --------

View a sample project that shows the result of following these steps in the sample/Serenity directory.

Within the project we are going to have three targets: a static library, a bundle, and an aggregate.

The static library target will build the source into a static library (.a) and specify which headers will be "public", meaning they will be accessible from the .framework when we distribute it.

The bundle target will contain all of our resources and will be loadable from the framework.

The aggregate target will build the static library for i386/armv6/armv7, generate the fat framework binary, and also build the bundle. You will run this target when you plan to distribute the .framework.

When you are working on the framework you will likely have an internal application that links to the framework. This application will link to the static library target as you normally would and copy the .bundle in the copy resources phase. This has the benefit of only building the framework code for the platform you're actively working on, significantly improving your build times. We'll do a little bit of work in the framework project to ensure that you can use your framework in your app the same way a third party developer would (i.e. importing <MyFramework/MyFramework.h> should work as expected). Jump to the dependent project walkthrough.

Create the Static Library Target --------------------------------

Step 1: Create a New "Cocoa Touch Static Library" Project

The product name will be the name of your framework. For example, Serenity will generate Serenity.framework once we've set up the project.

Step 2: Create the Primary Framework Header

Developers expect to be able to import your framework by importing the <Serenity/Serenity.h> header. Ensure that your project has such a header (if you created a new static library then there should already be a Serenity.h and Serenity.m file; you can delete the .m).

Within this header you are going to import all of the public headers for your framework. For example, let's assume that we have some Widget with a .h and .m. Our Serenity.h file would look like this:

#import <Foundation/Foundation.h>

#import <Serenity/Widget.h>

Once you've created your framework header file, you need to make it a "public" header. Public headers are headers that will be copied to the .framework and can be imported by those using your framework. This differs from "project" headers which will not be distributed with the framework. This distinction is what allows you to have a concept of public and private APIs.

To modify the scope of any header, select the header in the project explorer and then expand the Utilities pane (Cmd+Option+0).

Look at the "Target Membership" group and ensure that the checkbox next to the .h file is checked. Change the scope of the header from "Project" to "Public". This will ensure that the header gets copied to the correct location in the copy headers phase.

Step 3: Update the Public Headers Location

By default the static library project will copy private and public headers to the same folder: /usr/local/include. To avoid mistakenly copying private headers to our framework we want to ensure that our public headers are copied to a separate directory, e.g. $(PROJECT_NAME)/Headers. To change this setting, select the project in the file explorer and then click the "Build Settings" tab. Search for "public headers" and then set the "Public Headers Folder Path" to "$(PROJECT_NAME)/Headers" for all configurations. If you are working with multiple Frameworks make sure that this folder is unique.

Ongoing Step: Adding New Sources to the Framework

Whenever you add new source to the framework you must decide whether to expose the .h publicly or not. To modify a header's scope you will follow the same process as Step 2. By default a header's scope will be "Project", meaning it will not be copied to the framework's public headers.

Step 4: Disable Code Stripping

We do not want to strip any code from the library; we leave this up to the application that is linking to the framework. To disable code stripping we must modify the following configuration settings:

"Dead Code Stripping" => No (for all settings)
"Strip Debug Symbols During Copy" => No (for all settings)
"Strip Style" => Non-Global Symbols (for all settings)

Step 5: Prepare the Framework for use as a Dependent Target

In order to use the static library as though it were a framework we're going to generate the basic skeleton of the framework in the static library target. To do this we'll include a simple post-build script. Add a post-build script by selecting your project in the file navigator and clicking the "Build Phases" tab. From here, click "Add Build Phase" => "Add Run Script" and paste the following script in the source portion of the run script build phase. You can rename the phase by clicking the title of the phase (I've named it "Prepare Framework", for example).

set -e

mkdir -p "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/Versions/A/Headers"

# Link the "Current" version to "A"
/bin/ln -sfh A "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/Versions/Current"
/bin/ln -sfh Versions/Current/Headers "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/Headers"
/bin/ln -sfh "Versions/Current/${PRODUCT_NAME}" "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/${PRODUCT_NAME}"

# The -a ensures that the headers maintain the source modification date so that we don't constantly
# cause propagating rebuilds of files that import these headers.

This will generate the following folder structure:

-- Note: "->" denotes a symbolic link --

  Headers/ -> Versions/Current/Headers
  Serenity -> Versions/Current/Serenity
    Current -> A

Try building your project now and look at the build products directory (usually ~/Library/Developer/Xcode/DerivedData/<ProjectName>-<gibberish>/Build/Products/...). You should see a libSerenity.a static library, a Headers folder, and a Serenity.framework folder that contains the basic skeleton of your framework.

Create the Framework Distribution Target ----------------------------------------

When actively developing the framework we only care to build the platform that we're testing on. For example, if we're testing on the iPhone simulator then we only need to build the i386 platform.

This changes when we want to distribute the framework to third party developers. The third-party developers don't have the option of rebuilding the framework for each platform, so we must provide what is called a "fat binary" version of the static library that is comprised of the possible platforms. These platforms include: i386, armv6, and armv7.

To generate this fat binary we're going to build the static library target for each platform.

Step 1: Create an Aggregate Target

Click File => New Target and create a new Aggregate target. Title it something like "Framework".

Step 2: Add the Static Library as a Dependent Target

Add the static library target to the "Target Dependencies".

Step 3: Build the Other Platform

To build the other platform we're going to use a "Run Script" phase to execute some basic commands. Add a new "Run Script" build phase to your aggregate target and paste the following code into it.

set -e
set +u
# Avoid recursively calling this script.
    exit 0
set -u


# The following conditionals come from

if [[ "$SDK_NAME" =~ ([A-Za-z]+) ]]
    echo "Could not find platform name from SDK_NAME: $SDK_NAME"
    exit 1

if [[ "$SDK_NAME" =~ ([0-9]+.*$) ]]
    echo "Could not find sdk version from SDK_NAME: $SDK_NAME"
    exit 1

if [[ "$SF_SDK_PLATFORM" = "iphoneos" ]]

    echo "Could not find platform name from build products directory: $BUILT_PRODUCTS_DIR"
    exit 1

# Build the other platform.

# Smash the two static libraries into one fat binary and store it in the .framework

# Copy the binary to the other architecture folder to have a complete framework in both.

Important Note

The above script assumes that your library name matches your project name in the following line:


If this is not the case (e.g. your xcode project is named SerenityFramework and the target name is Serenity) then you need to explicitly set the target name on that line. For example:


Step 4: Build and Verify

You now have everything set up to build a distributable .framework to third-party developers. Try building the aggregate target. Once it's done, expand the Products folder in Xcode, right click the static library and click "Show in Finder". If this doesn't open Finder to where the static library exists then try opening ~/Library/Developer/Xcode/DerivedData/<project name>/Build/Products/Debug-iphonesimulator/.

Within this folder you will see your .framework folder.

You can now drag the .framework elsewhere, zip it up, upload it, and distribute it to your third-party developers.

Resources and Bundles =====================

To distribute resources with a framework, we are going to provide the developer with a separate .bundle that contains all of the strings and resources. This distribution method provides a number of advantages over including the resources in the .framework itself.

  • Encapsulation of resources. We can scope resource loading to our framework's bundle.
  • Easy to add bundles to projects.
  • The developer doesn't have to copy the entire .framework into their application.

The hard part about bundles is creating the target. Xcode's bundle target doesn't actually create a loadable bundle object, so we have to do some post-build massaging of the bundle. It's important that we create a bundle target because we need to create the bundle using the Copy Bundle Resources phase that will correctly compile .xib files (a Copy Files phase does not accomplish this!).

Step 1: Create the Bundle Target

In the framework project, create a new bundle target. You will need to name the bundle something different from your framework name or Xcode will not let you create the target. I've named the target SerenityResources. We will rename the output of the target to Serenity.bundle in a following step.

Ensure that the Framework setting is set to "Core Foundation".

Step 2: Clean up the Bundle Target Settings

By default the bundle will only show build settings for Mac OS X. It doesn't really matter what it builds for because the bundle isn't actually going to have any code in it, but I prefer to have things nice and consistent. Open the bundle target settings and delete the settings for Architectures, Base SDK, and Build Active Architecture Only.

This is also when you should change your bundle target's product name to the name of your framework rather than the target name. To do so, click your project in the Xcode file explorer, select the bundle target, and then click the Build Settings tab. Search for Product Name and then replace the value of Product Name with the name of your framework.

Ongoing Step: Add Resources to the Bundle Target Copy Files Phase

Whenever you add new resources that you want to include with your framework you need to add it to the bundle target that you created.

Step 3: Add the Bundle Target to your Aggregate Target

Whenever we build the framework for distribution we likely also want to build the bundle. Add the bundle target to your aggregate target's dependencies.

Step 4: Loading Bundle Resources

In order to load bundle resources, we must first ask the third-party developer to add the .bundle to their application. To do so they will simply drag the .bundle that you distributed with the .framework to their project and ensure that it is copied in the copy files phase of their app target.

To load resources from the bundle we will use the following code:

// Load the framework bundle.
+ (NSBundle *)frameworkBundle {
  static NSBundle* frameworkBundle = nil;
  static dispatch_once_t predicate;
  dispatch_once(&predicate, ^{
    NSString* mainBundlePath = [[NSBundle mainBundle] resourcePath];
    NSString* frameworkBundlePath = [mainBundlePath stringByAppendingPathComponent:@"Serenity.bundle"];
    frameworkBundle = [[NSBundle bundleWithPath:frameworkBundlePath] retain];
  return frameworkBundle;

[UIImage imageWithContentsOfFile:[[[self class] frameworkBundle] pathForResource:@"image" ofType:@"png"]];

You can see an example of loading a resource from within the framework in the Widget object in the included Serenity framework.

Adding the Framework to a Third-Party Application =================================================

View a sample project that shows the result of following these steps in the sample/ThirdParty directory.

This is the easy part (and what your third-party developers will have to do). Simply drag the .framework to your application's project, ensuring that it's being added to the necessary targets.

Import your framework header and you're kickin' ass.

#import <Serenity/Serenity.h>


If you're distributing resources with your framework then you will also send the .bundle file to the developers. The developer will then drag the .bundle file into their application and ensure that it's added to the application target.

Developing the Framework as a Dependent Project ===============================================

View a sample project that shows the result of following these steps in the sample/DependentApp directory.

When developing the framework you want to minimize build times while ensuring that your experience roughly matches that of your third-party developers. We achieve this balance by only building the static library but treating the static library as though it were a framework.

Step 1: Add the Framework Project to your Application Project

To add the framework as a dependent target in your application, drag the framework's xcodeproj to Xcode and drop it in your application's frameworks folder. This will add a reference to the framework's xcodeproj folder.

Step 2: Make the Framework Static Library Target a Dependency

Once you've added the framework project to your app you can add the static library product as a dependency. Select your project in the Xcode file explorer and open the "Build Phases" tab. Expand the "Target Dependencies" group and click the + button. Select the static library target and click "Add".

Step 3: Link your Application with the Framework Static Library

In order to use the framework's static library we must link it into the application. Expand the "Link Binary With Libraries" phase and click the + button. Select the .a file that's exposed by your framework's project and then click add.

Step 4: Import the Framework Header

You now simply need to import the framework header somewhere in your project. I generally prefer the pch so that I don't have to clutter up my application's source with framework headers, but you can obviously choose whatever practice suits your needs.

#import <Serenity/Serenity.h>

Step 4-b: Adding Resources

If you are developing resources for your framework you can also add the bundle target as a dependency.

You must then add the bundle to the Copy Bundle Resources phase of your application by expanding the products folder of your framework product and dragging the .bundle into that section.

Step 5: Build and Test

Build your application and verify a couple things:

  • Your framework should be built before your application.
  • Your framework should be linked into the application.
  • You shouldn't get any compiler or linker errors.
License =======

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 3.0 Unported License, and code samples are licensed under the Apache 2.0 License.

To view a copy of this license, visit or send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.