I think we're actually largely in agreement here (at least on the technical issues). We both agree a developer can’t bundle or redistribute Apple’s libraries, and their code still runs by invoking Apple’s IP on the user’s device. Users can run what they want, but developers still depend on Apple’s code to have their apps function. Right?
I think what we're arguing over is: a developer can build and distribute their own code, but if that code needs Apple’s IP to work, whether or not the developer is using Apple’s IP. My stance is, yes, they're using Apple's IP and Apple should be able to set conditions on that use (like how Apple is paid), because the developer's app wouldn't function without Apple's IP (even if said IP lives on a phone sold to an end user). Please correct me if I'm wrong, but is your argument that because Apple has already sold that copy of iOS to an end user, Apple isn't entitled to charge developers for use of the code that already exists on the end user's phone?
If that is your argument, I'd push back and say that kind of use of Apple's IP needs Apple's permission under EU law.
Article 4 of the directive gives software authors the exclusive right to authorize:
- (a) reproduction, even temporary;
- (b) adaptation or alteration;
- (c) distribution to the public.
Even if the libraries are preinstalled on the user’s device (i.e., distribution is exhausted), the developer’s code executes Apple’s code at runtime. That counts as temporary reproduction (and possibly adaptation) under EU law. The EUCJ seems to agree with me, if my googling is correct.
Nintendo v. PC Box (C‑355/12)
The EUCJ ruled that Nintendo can use technical protection measures to block unlicensed software if those measures are proportionate to preventing piracy. Circumventing those measures, like running unauthorized apps, can infringe IP rights, even if done for “legitimate” purposes.
If your interpretation was correct, circumventing those measures wouldn't violate IP rights, because it was done on the user's legally-purchased console.
I think you have narrowed it down with what our core disagreement might circulate around.
Once again you're misinterpreting a ruling. This is what those points say.
- Functionality, programming languages, and data formats are not protected by copyright. You can emulate a program’s functionality but not copy the actual code, UI, or structure of the original.
- Reverse engineering is permitted under certain conditions. If you lawfully obtain software, you can study or observe it to understand how it works, but only to ensure interoperability and not to build a competing product in violation of license terms. Note the key phrase at the end of point 2 in your screenshot "on condition that that person does not infringe the exclusive rights of the owner of the copyright in that program."
Why this ruling doesn't apply here:
- This ruling doesn’t grant a right to use someone else’s proprietary APIs or SDKs in your own product without a license. Apple’s SDKs are not simply “functional ideas.” They include expressive code, UI elements, documentation, and platform-specific tools. Using them directly requires reproducing and linking against Apple’s copyright-protected code.
- World Programming wrote its own code to replicate SAS’s functionality without accessing or copying its source. That’s completely different from developers who build iOS apps by importing Apple frameworks and distributing binaries that link to Apple’s runtime libraries. That’s not "observing behavior," it's using the platform.
- Developers using Apple’s SDKs don’t just observe. They integrate and depend on Apple’s IP.
Running an app on iOS involves things like using Apple's proprietary libraries, linking against Apple-owned frameworks, calling Apple-owned APIs.
- In short, the ruling you cited only allowed replication of functionality, not reuse of the original software or its components. Apple’s SDKs, APIs, and tools contain Apple owned code and expression that the developers' iOS apps use directly. That’s not "reverse engineering" or "functional emulation" it’s active use of Apple’s IP, and under EU law I cited above, that requires a license.
But that’s the thing it’s a question regarding the software being deployed are enacted by the user. How will you argue that the software developer is violating IP rights when they are at no time violating said rights.
Even if we assume some of your points are correct, your overall interpretation still doesn’t hold water under EU law and leads to legal paradoxes nobody wants.
Let’s take your strongest claims as given:
- Apple’s APIs and libraries are fully protected copyrighted works (even though SAS v. WPL clearly ruled APIs and functionality aren’t copyrightable).
- Any invocation of those APIs by a developer’s app counts as “use” of Apple’s IP that requires a license.
- Apple’s platform restrictions are justified under Article 6 or similar provisions.
How can a developer infringe Apple’s IP when all software execution happens on the user’s device, under their control? Even if we assume Apple’s APIs and libraries are fully copyrighted, and calling them requires a license, your view still fails under EU law.
Directive 2009/24/EC Article 4 grants exclusive rights over reproduction, adaptation, and distribution—but Article 5 allows lawful users to run software and make temporary copies as needed. If calling APIs counted as infringement, these exceptions would be nullified, which contradicts the directive’s purpose.
This is critical: if a user has lawfully acquired the device(as has already been established as a purchase and transfer of ownership)(with iOS and its libraries), then execution of iOS APIs on that device including when invoked by third-party apps are permitted without further authorization. This is settled EU law. The lawful acquirer (the device owner) has rights that are not extinguished just because a developer’s code triggers preinstalled APIs.
When they install a third-party app that calls Apple’s libraries, it’s the user, not the developer, who’s actually “using” Apple’s code.
2. Misunderstanding of Exhaustion and Lawful Use
The claim that apps invokes Apple’s IP (even if preinstalled), the developer must get a license. But this misreads how copyright exhaustion and user rights work in EU software law.
Distribution right is exhausted once Apple sells the device with iOS and libraries preinstalled. The buyer (end user) is now a lawful acquirer.
What the developer does is provide code that interacts with the user’s device. The developer is not distributing iOS or Apple’s IP; they’re distributing code that expects certain OS features to be present.
It’s akin to writing a Word macro, you’re using MS Word’s runtime behavior, but you’re not copying Word.
As a lawful acquirer of iOS and the iPhone , the user has the right to run and execute that software (Article 5(1)). So when they install a third-party app that calls Apple’s libraries, the actual use of Apple’s code is by the user, not the developer.
The developer does not reproduce or distribute Apple’s code
Your interpretation conflates calling a library with copying or distributing that library. The developer’s binary is their own code and does not contain Apple’s code. Apple’s software is already on the device. EU law requires reproduction or distribution to infringe copyright (Article 4). None of that happens here.
If API invocation were infringement, everyday software development would be illegal
Your theory would mean the moment I run software on any device I would invoke copyright infringement by proxy of the software developer.
And This logic would impose indirect liability on developers for lawful user behavior Developers would be indirectly liable whenever users execute apps that call into preinstalled system libraries.
That would create a bizarre strict liability regime, where lawful user behavior (running software) causes third-party copyright infringement by proxy. That’s a form of copyright by proxy that EU law does not recognize.
So even if we assume that Apple’s APIs and libraries are fully protected IP (which they arguably aren’t, per SAS Institute), the C-159/23
Sony v Datel confirms that using those APIs at runtime is not an infringing act by the developer.
In other words, your position that developers must have a license simply to call Apple’s system libraries fails under this ruling. It rejects any theory that runtime use or invocation is equivalent to reproduction or distribution.
If Apple really wanted to control this, they’d have to prohibit users themselves from running apps that call these libraries, which of course they can’t do because the user owns the device and software copy as a legally purchased product.
Copyright Boundaries Software Directive 2009/24/EC Affected by cases
- interpretation requested by 62010CN0406 (C-406/10 SAS v WPL)
- A04P2 Interpreted by 62011CJ0128 (C-128/11 Usedsoft v Oracle)
- A05P1 Interpreted by 62011CJ0128 (C-128/11 Usedsoft v Oracle)
- interpretation requested by 62011CN0128 (C-128/11 Usedsoft v Oracle)
- article 4 paragraph 2 Preliminary question submitted by 62015CN0166 (C-166/15)
- article 5 paragraph 1 Preliminary question submitted by 62015CN0166 (C-166/15)
- article 5 paragraph 2 Preliminary question submitted by 62015CN0166 (C-166/15)
- Interpreted by 62018CJ0666 (C-666/18 Top System)
- article 1 paragraph 1 Preliminary question submitted by 62018CN0313 (Case C-313/18)
- article 2 paragraph 3 Preliminary question submitted by 62018CN0313 (Case C-313/18)
- article 4 paragraph 1 point (b) Preliminary question submitted by 62018CN0313 (Case C-313/18)
- article 4 Preliminary question submitted by 62018CN0666 (C-666/18 Top System)
- article 7 Preliminary question submitted by 62019CN0785
- article 7 Preliminary question submitted by 62020CN0559
- Interpreted by 62023CJ0159 (C-159/23, Sony v Datel)
- article 1 paragraph 1 Preliminary question submitted by 62023CN0159 (C-159/23, Sony v Datel)
- article 1 paragraph 2 Preliminary question submitted by 62023CN0159 (C-159/23, Sony v Datel)
- article 1 paragraph 3 Preliminary question submitted by 62023CN0159 (C-159/23, Sony v Datel)
- article 4 paragraph 1 point (b) Preliminary question submitted by 62023CN0159 (C-159/23, Sony v Datel)
CJEU ruling in C-666/18 (Top System): ruled that developers have the right to observe, study, and test software to achieve interoperability, even if license agreements say otherwise.
- The case dealt with whether a software license agreement can prohibit the licensee from observing, studying, or testing the software in ways necessary for interoperability.
- The CJEU ruled that contractual clauses prohibiting such activities are invalid under EU law if they conflict with the exceptions to copyright in Directive 2009/24/EC.
- Specifically, the ruling confirms that Article 6 of the Software Directive grants the lawful acquirer the right to observe, study, or test a program to achieve interoperability with independently created software.
- This right prevails even if the license agreement tries to restrict it
So, even if Apple’s SDK or APIs are “protected,” developers are legally allowed to create compatible software by studying and interacting with the platform, without infringing copyright or breaching license terms.This reinforces the principle that post-sale restrictions Apple tries to impose via licensing cannot override fundamental statutory exceptions. It’s another nail in the coffin of the argument that any third-party API use without a license equals infringement.
CJEU ruling in Sony v Datel (C-159/23) which directly undermines the claim that merely invoking system-level code constitutes copyright infringement.
- The court made clear that copyright protection only covers the actual source and object code of a program not the functional elements or runtime data manipulated during execution.
- Datel’s software, which changed variables temporarily in RAM on Sony’s console to alter game behavior, was ruled not to infringe because it didn’t reproduce, copy, or redistribute Sony’s code.
- By analogy, when an iOS app calls Apple’s preinstalled APIs, it does not copy or distribute Apple’s copyrighted code. It merely triggers execution of code that already resides lawfully on the user’s device.
- This kind of runtime interaction passing parameters, getting responses is exactly what Sony v Datel found to be outside copyright scope since it doesn’t create new copies or adaptations of the protected software