Software copyright protects the expression in a program’s code, not what the program does. Source code and object code are both literary works under 17 U.S.C. § 101, and protection vests automatically the instant the code is fixed, with no registration, notice, or filing required. What copyright will not give you is the algorithm, the data format, the protocol, or the function itself.
That split is the whole subject. Section 102(b) says in plain terms that copyright extends to no idea, procedure, process, system, method of operation, concept, principle, or discovery, regardless of the form in which it is described in the work. Code is unusually bad at staying on the protected side of that line, because code is written to do things. Almost every dispute over software copyright is an argument about which parts of a program are expression and which parts are the method of operation wearing expression’s clothes.
Congress added the definition of “computer program” to § 101 in 1980, following the CONTU report: a set of statements or instructions to be used directly or indirectly in a computer in order to bring about a certain result. That places programs in the literary works category of § 102(a), alongside novels and technical manuals, which is doctrinally odd but consequential: literary works get the full suite of exclusive rights in § 106, including reproduction and derivative works.
The early fight was whether machine-readable code counted at all. In Apple Computer, Inc. v. Franklin Computer Corp., 714 F.2d 1240 (3d Cir. 1983), Franklin argued that object code embedded in ROM was a mechanical part of a machine rather than a work of authorship. The Third Circuit rejected that: a program is protected whether it is in source or object form, and whether it sits on paper or burned into silicon. Operating systems are protectable too, notwithstanding the argument that they are pure method.
Literal copying is verbatim or near-verbatim reproduction of code text. It is the easy case, and modern versions look like a departing engineer pushing a repository to a personal account, or a vendor shipping a library it never licensed. Proof is usually forensic rather than doctrinal, and things like identical comments, dead code, and copied typos are what actually win those cases.
Non-literal copying is harder and more interesting. It is the claim that a rewrite in a different language, with no shared lines, still took the program’s structure, sequence, and organization. The Third Circuit went far in Whelan Associates v. Jaslow Dental Laboratory, 797 F.2d 1222 (1986), holding that a program’s purpose is the unprotected idea and everything not necessary to that purpose is protectable expression. That rule swallowed the exception, and courts abandoned it.
The replacement came from Computer Associates International, Inc. v. Altai, Inc., 982 F.2d 693 (2d Cir. 1992), and it is now the dominant framework in the federal courts. It runs in three steps:
Filtration is where most software claims lose weight. Merger removes expression when there are only a few ways to express an idea, which describes a lot of code because efficient solutions converge. Scenes a faire removes elements that are standard, stock, or dictated by the environment, which in software means anything the operating system, the file format, the compiler, or the protocol required you to write that way.
The sharpest statement of the § 102(b) limit came in Lotus Development Corp. v. Borland International, 49 F.3d 807 (1st Cir. 1995). Borland copied the Lotus 1-2-3 menu command hierarchy into Quattro Pro so that users could keep their macros. The First Circuit held the hierarchy was an uncopyrightable method of operation: it was how users operated the program, no different in kind from the buttons on a VCR, and the fact that Lotus could have arranged the commands differently did not convert the method into expression. The Supreme Court affirmed by an equally divided Court, 516 U.S. 233 (1996), which left the holding binding only in the First Circuit and left the country split.
Interfaces raise the same problem in a stronger form, because interoperability is an external constraint by definition. The Ninth Circuit’s Sega Enterprises v. Accolade, 977 F.2d 1510 (1992), and Sony Computer Entertainment v. Connectix, 203 F.3d 596 (2000), both held that intermediate copying performed solely to reverse-engineer unprotected interface specifications was fair use, on the reasoning that requiring a license would hand the copyright owner a monopoly over the functional ideas the code contained.
Google LLC v. Oracle America, Inc., 593 U.S. 1 (2021), is the modern anchor. Google reused roughly 11,500 lines of declaring code from the Java SE API so that Java programmers could carry their skills to Android, and wrote its own implementing code underneath. The Court assumed without deciding that the declaring code was copyrightable, then held the copying was fair use as a matter of law. The reasoning matters more than the result: declaring code is inherently bound up with uncopyrightable ideas and with the investment of programmers who learned the calls, its value comes substantially from the community of developers rather than from Oracle’s authorship, and Google took only what was needed to let those programmers work in a new environment. Copyrightability of APIs remains formally open.
Copyright exists without registration, but registration is a precondition to filing an infringement suit for a U.S. work under § 411(a), and Fourth Estate v. Wall-Street.com (2019) held that means an actual grant or refusal, not just a submitted application. Registration before infringement, or within three months of publication, is also what unlocks statutory damages and attorney’s fees under § 412.
Deposit is the friction point. The Copyright Office’s rule for computer programs, 37 C.F.R. § 202.20(c)(2)(vii), normally requires the first 25 and last 25 pages of source code, which is a public record. Because source code is usually also a trade secret, the rule itself offers alternatives: blocking out portions of the listing, so long as an appreciable amount of original code stays visible and the blocked material is proportionately less than the visible material; depositing the first and last 10 pages with nothing blocked out; or depositing the first and last 25 pages of object code together with 10 or more consecutive pages of source code, which the Office registers under the rule of doubt because it cannot read object code to confirm copyrightable authorship. Choosing the wrong option can weaken later proof of what was registered.
Copyright is the default and it is nearly free, but it only stops copying. An engineer who independently writes the same function infringes nothing, and clean-room reimplementation is a lawful strategy precisely because copyright has no reach over independent creation. Term for a work made for hire is 95 years from publication or 120 from creation, whichever expires first.
A patent reaches the method itself, including against independent inventors, but it costs real money, takes years, expires 20 years from filing, publishes the invention, and has to survive the Alice Corp. v. CLS Bank abstract-idea framework, which invalidates a substantial share of software claims.
A trade secret protects the algorithm as long as it is not disclosed and reasonable secrecy measures are kept, but it evaporates on lawful reverse engineering or independent discovery. Most software companies use all three at once: copyright on the codebase, patents on a handful of methods worth the spend, and trade secrecy on everything the binary does not reveal.
Is software protected by copyright? Yes. A computer program is a literary work under 17 U.S.C. § 101, defined as a set of statements or instructions used directly or indirectly in a computer to bring about a certain result. Protection attaches automatically the moment the code is written to disk, and it covers both human-readable source code and machine-readable object code. Apple Computer v. Franklin Computer settled the object-code question in 1983.
What does software copyright actually protect? The expression, not the function. Section 102(b) withholds protection from any idea, procedure, process, system, or method of operation, no matter how it is described in the work. So copyright reaches the particular way you wrote the code, including literal text and some non-literal structure, but it never gives you the algorithm, the protocol, or the task the program performs. Someone who reads your documentation and writes their own implementation has not infringed.
Does copyright cover an API? Unsettled. In Google v. Oracle (2021) the Supreme Court assumed for argument’s sake that the 11,500 lines of Java declaring code Google copied were copyrightable, then held the reuse was fair use as a matter of law, expressly declining to decide the copyrightability question. The Federal Circuit’s earlier holding that API declaring code can be copyrightable went unreviewed, so it remains on the books while the practical outcome favored reimplementation.
Is copyright or a patent better for software? They protect different things and are not substitutes. Copyright is free, automatic, runs 95 years from publication or 120 from creation for a work made for hire, whichever expires first, and stops copying but not independent creation. A patent can reach the underlying method, but it must be applied for, costs real money, lasts 20 years from filing, and faces the Alice eligibility problem. Trade secret is the third option and it protects the algorithm itself, for as long as it stays secret.
Going further: Open Source and Software IP, the practical playbook .
This page is general legal information, not legal advice, and it does not create an attorney-client relationship.
The Third Circuit's 1983 ruling that object code, ROM firmware, and operating systems are copyrightable expression built the software industry's legal floor.
Whelan v. Jaslow (3d Cir. 1986) stretched software copyright past literal code to structure, sequence, and organization, a high-water mark Altai later curbed.
A December 2025 summary-adjudication order in Software Freedom Conservancy v. Vizio narrows the case but leaves the central question intact: whether an ordinary purchaser can enforce open-source copyleft as a third-party beneficiary on the eve of an August 2026 trial.
The Supreme Court held that Google's copying of about 11,500 lines of Java API declaring code to build Android was a fair use as a matter of law, reshaping software copyright.
The Ninth Circuit held that copying object code to study a program's unprotected functional elements can be fair use, securing reverse engineering as a tool for interoperability and competition.
The Ninth Circuit held that intermediate copying of Sony's PlayStation BIOS to reverse engineer a lawful emulator was fair use, protecting interoperability and cementing the Sega v. Accolade rule.
The Ninth Circuit held that loading copyrighted software from disk into RAM creates a fixed copy under the Copyright Act, exposing third-party repair technicians to infringement liability.
The First Circuit held that the Lotus 1-2-3 menu command hierarchy is an uncopyrightable 'method of operation' under Section 102(b), a ruling left standing by an evenly divided Supreme Court.
The Ninth Circuit's December 2024 decision holds that software built to interoperate with a copyrighted program is not a derivative work without 'something more': actual copying of protected expression.
