Apple v. Franklin: Copyright | Outside IP Counsel

The Third Circuit's 1983 ruling that object code, ROM firmware, and operating systems are copyrightable expression built the software industry's legal floor.

In August 1983, the software industry got the property right it had been operating on faith. Apple Computer, Inc. v. Franklin Computer Corp., 714 F.2d 1240 (3d Cir. 1983), decided August 30, 1983, was the first federal appellate decision to hold that operating system programs are copyrightable, and that protection extends to object code, the unreadable binary form of a program, even when burned into a ROM chip. Franklin had built its ACE line of Apple II-compatible computers by copying Apple’s system software nearly byte for byte, and it defended the copying not by denying it but by arguing that what it took was not copyrightable at all.

The Third Circuit, in an opinion by Judge Dolores Sloviter, rejected every version of that argument, reversing a district court that had refused Apple a preliminary injunction and settling the foundational question the Copyright Act’s 1980 software amendments had left to the courts. Every later fight over software copyright, from Whelan v. Jaslow through Computer Associates v. Altai to Google v. Oracle, starts from the floor this case laid: code is a literary work, whatever form it takes.

At a glance

Case: Apple Computer, Inc. v. Franklin Computer Corp., 714 F.2d 1240 (3d Cir. 1983)
Decided: August 30, 1983; panel of Judges Sloviter, Hunter, and Higginbotham; opinion by Judge Sloviter; reversed and remanded
Holding: Computer programs are copyrightable in object code form and when embedded in ROM, and operating systems are not excluded from protection as uncopyrightable processes, systems, or methods of operation under 17 U.S.C. § 102(b).
Status: Final. The parties settled on January 4, 1984, with Franklin agreeing to pay Apple $2.5 million and to stop selling machines carrying the copied code by April 1, 1984. Franklin’s certiorari petition was dismissed the same day, 464 U.S. 1033 (1984).

The statutory landscape after the 1980 amendments

The Copyright Act of 1976 protected “original works of authorship fixed in any tangible medium of expression,” but it said nothing explicit about software until Congress acted on the recommendations of the National Commission on New Technological Uses of Copyrighted Works (CONTU). CONTU’s 1979 Final Report concluded that programs were proper subject matter, and the 1980 amendments codified the recommendation: 17 U.S.C. § 101 now defined a “computer program” as “a set of statements or instructions to be used directly or indirectly in a computer in order to bring about a certain result,” and a new § 117 gave program owners limited rights to make copies and adaptations, an exception that presupposes the underlying work is protected.

The amendments did not answer the practical questions clone makers would raise. Source code, the human-readable text a programmer writes, looked comfortably like a literary work. Object code, the compiled string of ones and zeros a machine executes, did not. And an operating system, whose whole purpose is to make hardware run, struck some judges as more machine part than book. The Third Circuit had already taken the first step in Williams Electronics, Inc. v. Artic International, Inc., 685 F.2d 870 (3d Cir. 1982), holding that a video game program fixed in ROM was protectable. Franklin would decide whether that logic reached the software that mattered most commercially.

A clone maker’s candid defense

Franklin Computer Corporation launched its ACE 100 in 1982 as a deliberate Apple II compatible: a machine that could run the enormous library of application software written for Apple’s platform. Rather than write its own system software, Franklin copied fourteen of Apple’s operating system programs, including Applesoft BASIC and the Autostart ROM, works Apple said had cost 46 man-months of labor and over $740,000 to develop. The copying was not subtle: Apple’s programmer found his own name, James Huston, and the word “Applesoft” embedded in Franklin’s master disk, artifacts of code lifted wholesale with only Apple’s identifying references deleted.

Apple sued in the Eastern District of Pennsylvania on May 12, 1982, and moved for a preliminary injunction. At the hearing, Franklin’s own witness admitted copying each of the works in suit. Franklin’s defense was doctrinal: object code is not a “work of authorship,” programs etched into ROM are utilitarian machine parts rather than fixed writings, and operating systems are “processes” or “methods of operation” that § 102(b) places outside copyright. The district court denied the injunction, expressing doubt about the programs’ copyrightability and weighing the “devastating effect” an injunction would have on Franklin, the far smaller company, against Apple’s ability to absorb the loss. Apple appealed.

Object code and ROM: the medium does not matter

Judge Sloviter’s opinion dismantled the technical objections first. The statutory definition of a computer program covers instructions used “directly or indirectly” in a computer, and only object code is used directly; source code must first be compiled or interpreted. Reading the Act to protect the source text but not its machine-executable translation would protect the form of the work a computer never runs while leaving the commercially essential form free for the taking. The court also leaned on § 102(a)‘s instruction that a work may be fixed in any medium from which it can be perceived or reproduced with the aid of a machine or device. A ROM chip is such a medium. Following Williams Electronics, the panel held that embedding a program in silicon is fixation, not transformation into an unprotectable machine part, quoting CONTU’s line that programs should no more be considered machine parts than videotapes should be considered parts of projectors.

Neither point was entirely new after Williams, but Franklin generalized them beyond video games to the system software at the heart of the industry. After Franklin, the question was never again whether binary code on a chip could be copyrighted, only how far that copyright reached.

Operating systems, Section 102(b), and the merger doctrine

Franklin’s strongest argument was categorical: an operating system is a “process” or “method of operation” under § 102(b), the codification of Baker v. Selden, 101 U.S. 99 (1879), and so is unprotectable no matter how it is written. The court refused to carve operating systems out of the Act. The statutory definition of a computer program draws no line between application programs and operating programs; both instruct the computer to do something, and an operating system’s utilitarian output does not convert its text into a process. Citing Mazer v. Stein, 347 U.S. 201 (1954), the panel reiterated that a work’s utilitarian purpose does not strip it of protection. Section 102(b) denies protection to the process a program implements, not to the program’s particular written expression of it.

That left the merger doctrine, the rule that when an idea can be expressed in only one way, expression and idea merge and copyright yields. Here the court framed the test in a way that still governs: the question is whether other programs can be written that perform the same function. If so, the particular code chosen is protectable expression. Critically, the court defined the “idea” at the level of the function to be performed, not at the level Franklin urged, which was compatibility with the installed base of Apple software. Franklin wanted total compatibility with independently developed application programs, and achieving it may well have required Apple’s exact code. But that, the court said, is a commercial and competitive objective, not part of the idea/expression analysis. Merger protects the freedom to express an idea differently; it does not license copying whenever copying is the cheapest road into a competitor’s market.

Irreparable harm, remand, and what came after

The panel also corrected the district court’s equitable analysis. A copyright plaintiff who makes a prima facie showing of infringement is presumed to suffer irreparable harm, and the district court erred by demanding a detailed injury showing and by weighing the hardship an injunction would impose on the infringer. The denial was reversed and the case remanded, with the narrow merger question, whether some of the fourteen programs could only be written one way, left open along with Franklin’s challenges to Apple’s compliance with copyright formalities.

The endgame was brief. Rather than retry merger on remand, the parties settled on January 4, 1984: Franklin agreed to pay Apple $2.5 million and to stop selling machines carrying the copied code by April 1, 1984. The Supreme Court dismissed Franklin’s certiorari petition the same day, 464 U.S. 1033 (1984). By 1988 Apple had forced Franklin’s clones from the market. The larger consequence was industry-wide: verbatim cloning became legally untenable, pushing compatibility seekers toward clean-room engineering, in which developers who never saw the original code write a functional equivalent from a specification. Phoenix Technologies’ 1984 clean-room BIOS, which legitimized the PC-clone industry, was a direct response to the rule Franklin announced.

Open questions

Franklin answered whether software is copyrightable and deliberately left how much of it is. The opinion’s merger test worked cleanly for wholesale copying but gave little guidance for the harder cases that followed: nonliteral copying of a program’s structure, reimplementation of interfaces, and intermediate copying done to study a program. The Third Circuit’s own next step, Whelan Associates v. Jaslow Dental Laboratory, 797 F.2d 1222 (3d Cir. 1986), read Franklin expansively to protect structure, sequence, and organization, before Computer Associates International v. Altai, Inc., 982 F.2d 693 (2d Cir. 1992), pulled the doctrine back with the abstraction-filtration-comparison test. And Franklin’s dismissal of compatibility as a mere commercial objective sat uneasily with later decisions, from Sega v. Accolade to Google LLC v. Oracle America, Inc., 141 S. Ct. 1183 (2021), that treated interoperability as a value copyright law should accommodate through fair use. Whether compatibility-driven copying is theft or competition remains the live wire Franklin first exposed.

Implications for developers and businesses

Binary is protected, full stop. Shipping a product as compiled code, firmware, or a ROM image does not weaken copyright. Distributing binaries is distributing copies of a protected literary work, and copying them verbatim is infringement regardless of medium.
Compatibility is a goal, not a defense. Wanting your product to run a competitor’s ecosystem of software does not authorize copying the competitor’s code. The lawful path is independent implementation, and Franklin is the reason clean-room procedures became standard practice.
Merger arguments turn on how the idea is framed. Franklin pegs the idea to the function performed, not to the business objective served. Expect courts to ask whether the function could be coded differently, and build a factual record on that question.
Provenance artifacts decide cases. Franklin lost in part because Apple’s programmer’s name surfaced in Franklin’s own master disk. Treat embedded strings, comments, and metadata in acquired code as the forensic trail they are.

Frequently asked questions

Why was Apple v. Franklin such an important software copyright case? It was the first federal appellate decision to hold squarely that operating systems and machine-readable object code, including code embedded in ROM chips, are copyrightable. Before the ruling, clone makers argued that binary code was an uncopyrightable machine part or process. The Third Circuit’s rejection of those arguments gave the young software industry a reliable property foundation.

Did the decision make it illegal to build Apple-compatible computers? No. The court held only that Franklin could not achieve compatibility by copying Apple’s code verbatim. If a competitor independently writes its own operating system that runs the same application programs, copyright is no obstacle. That distinction later drove the clean-room development methods used to build lawful PC-compatible BIOS chips.

What happened to Franklin after the Third Circuit’s ruling? The parties settled on January 4, 1984, rather than litigate the narrow merger question the panel left open. Franklin agreed to pay Apple $2.5 million and to stop selling machines carrying the copied code by April 1, 1984, and the Supreme Court dismissed Franklin’s certiorari petition the same day. Apple had pushed Franklin’s clones off the market entirely by 1988.