Our DNA is written in Swift

Which OS Version to Target?

Now that OS 3.0 has been released and we know that the 3.1 bugfix release is on rails we have to re-evaluate the question which platforms we need to be able to support. On the one hand it might be nice to use all the new 3.0 bells and whistles. One the other hand though this could mean we risk losing half of our potential customers who are still on “old software”.

Besides simple disinterest or negligence the main reason for sticking with old software is that people are always waiting to hear from the iPhone Dev Team that a new version can be jailbroken and sim-unlocked. If you are using your iPhone in the network of your own choosing, you would not want to give this up even for the greatest new update.

From the developer’s point of view there are a couple of features (even before version 3.0) where you had to bump up the minimum OS version. I for one implemented the CLLocation properties course and speed in iFR Cockpit which only became available as of 2.2.

Just today Applyzer released an analysis of the required OS version for all apps on the store. Also AdMob frequently publishes metrics on OS versions in use. Let’s check those to get some guidance for our own apps.


Now 3.0 is out for a month and has been pwned, snowcracked, hacked, jailbroken and all those other nasty words that Apple wishes somebody would take out of the dictionary. So in the foreseeable future we will see most hesitant people move from 2.x to 3.0.

But for the time being we have to orient ourselves on the data at hand. So first, let’s see what platforms are targeted by our developing colleagues and competitors. I would have thought this number next to 2.0 to be higher, but only a third of apps are targeting the lowest possible platform.

Applyzer Chart

The reason cannot be iPhone OS 3.0 because there are only 2544 apps on the store that require this level. iPhone firmware releases with an x.1 are generally meant to only fix bugs and not bring great new features. Maybe because of this half of developers skipped 2.1 and went to 2.2/2.2.1, because either they wanted to get to the couple of new things in the x.2 release or because they thought they would have less trouble by only supporting customers with a stable release.

To summarize: Who can still support 2.0 does so. Who needs new features of 2.2 requires this version. 2.1 only makes sense if it fixes a bug that otherwise impacts your app. But I can honestly say that apart from the Core Location thing I mentioned above I see no reason in my apps to not choose 2.0.

That’s what developers think, how about what the customers are really doing with their precious devices?

The following pie chart might be somewhat skewed because generally only free apps use advertising. One might argue that people who have funds to purchase the latest and greatest in hardware could not be bothered with ad-sponsored variants of apps but would also spend top dollar for top apps. But just as valid is the argument that due to the sheer size of the sample it most likely represents the market rather accurately.

The gist: Half 3.0, Half 2.2.1. Probably a strong trend towards 3.0 now that the final “hurdles” (wink, wink) have fallen.

AdMob OS Versions

But that’s the iPhone where OS updates are free. Apple continues to take fire “out of bookkeeping reasons”. Most iPod Touch users don’t see a compelling reason to updated to 3.0 for $10. Music plays the same and why do I need push on a music player?

AdMob iPod Touch

And THAT is what really hurts if are itching to do 3.0 magic. Next to none of the iPods out there are running on the shiny new OS version. According to my own stats there are 55% iPhones versus 45% iPod Touches.

If you do the math by multiplying this percentage versus the 2.x/3.0 percentages you find that about 75% of devices can run some 2.x flavor and only 25% are immediately available as customer base for 3.0 apps. If all iPhone users now on 2.2.1 would shift to the newer version the total number moves to 51% old versus 49% new.

So even in a best case scenario you effectively cut your potential market in half by going for the hot new features like in-app-purchases, peer-to-peer multiplayer and push notifications. No question about it, big productions are taking the field by storm because they effectively know how to cheat!

Take Tap Tap Revenge 2.6 as an example. According to iTunes they target 2.0 but have found a loophole that allows them to load the push notification framework depending on the device it’s running on. I know of only one other developer who is trying to figure out how to achieve this dynamic loading.

For us regular dev folk it probably will not make fiscal sense to do 3.0-only apps in the short term unless we’re doing it for the fun of it. Hey, I’d rather earn a little money constantly than only HALF of little money. Unless I revolutionize something with my apps, but how likely is that? Know any app store jackpot winners? I don’t. We all get by, of sorts.

Apple, are you reading this?! Why not give us the tools that the big guys have to dynamically load 3.0 frameworks on 3.0 platforms and still be able to serve the big and non-diminishing 2.x market? Because then also small budget apps would start getting 3.0 features which might build up to critical mass to push more and more iPod users to shell out $10 for the update. Oh my, when has favoritism towards big companies ever really gained you something?

A call to action rounds off this article: let’s figure out this dynamic loading Voodoo ourselves and share it with each other.

Categories: Apple


  1. Good Morning, Oliver!
    You’ve published great stats and you’re asking a clever question. I can answer with our own stats, collected within the highscore of our Super Trumps games:

  2. It’s not a magic function to run 3.0 feature on a 2.0 build. There are 2 way to the “magic”:
    1) check the firmware version:
    +(int) iPhoneOSMajorVersion {
    if (majorVersion == 0) {
    NSString * version = [[UIDevice currentDevice] systemVersion];
    majorVersion = [[version substringToIndex:1] intValue];
    return majorVersion;

    +(BOOL) isIPhoneOS3 {
    return [self iPhoneOSMajorVersion] >= 3;

    if ([xxx isIPhoneOs3]) {
    // iphone 3.0 stuffs.
    } else {
    // iphone 2.0 stuffs

    2) check if the current firmware implements the selector you need to call:

    if ([obj respondsToSelector:@selector(selnameThatWorksOnlyIn3)]) {
    [obj selnameThatWorksOnlyIn3];
    } else {
    [obj oldSelectorThatWorksOn2];

    The last method is the best method, because it’s always better to check if the selector exists (things can change from firmware to firmware), but it’s better if you save the result of respondsToSelector in a global BOOL so you can easily check later if the selector exists without calling the method every time

  3. But how would you load 3.0 frameworks on 2.0 builds? To use a framework you need to include the headers and those reject to be loaded on pre 3.0, unless you hack them…

  4. You use the 3.0 sdk and build against 2.2.
    I can swear you that it works 🙂
    If you search the apple dev forums, you can find answer from apple engineers that recommend this way.

  5. Wow, that’s amazing. I finally see how it can be possible to achieve that Tap Tap Revenge is doing!

    I have to work up a recipe once I can find time to make an example.