Software Patents: How They Work, Why They're Controversial, and Key Cases

What Is a Software Patent?

A software patent is a patent that protects an invention that is implemented in software—an algorithm, a method of processing data, a user interface technique, or a system that performs some function using computer code. Like other patents, a software patent gives the patent holder the exclusive right to use, make, sell, and license the patented invention for a period of 20 years from the filing date, in exchange for publicly disclosing the invention. Anyone who uses the patented method without authorization during that period may be liable for patent infringement, regardless of whether they independently developed the same technique.

The defining feature of a software patent—and the source of much controversy—is that it protects not the specific code that implements a function but rather the underlying method or algorithm itself. A patent on a method for compressing data, for sorting records, or for displaying information on a screen can prevent any developer from using that method in any software, regardless of whether they wrote their own code from scratch. This is fundamentally different from copyright protection, which protects the specific expression of an idea (the actual code) but allows others to independently create different code that accomplishes the same function.

The scope and validity of software patents has been hotly debated and heavily litigated since the patent system began grappling with software inventions in the 1970s and 1980s. The debate involves fundamental questions about the nature of software—is it more like a mathematical formula (traditionally unpatentable) or like a mechanical process (patentable)?—as well as practical questions about whether software patents promote or inhibit innovation. These questions have been addressed in a series of landmark court decisions that have shaped the current legal landscape, but significant uncertainty remains.

Requirements for a Software Patent

To be patentable in the United States, an invention—including a software-implemented invention—must meet several requirements established by the Patent Act and interpreted through case law. The invention must be novel (not previously known or used), non-obvious (not an obvious extension of existing knowledge to a person of ordinary skill in the field), and useful. It must also be directed to patentable subject matter under 35 U.S.C. Section 101, which permits patents on processes, machines, manufactures, and compositions of matter but excludes abstract ideas, laws of nature, and natural phenomena from patent protection.

The subject matter eligibility requirement under Section 101 has been the primary battleground for software patents. Courts and the Patent and Trademark Office have struggled for decades to articulate a workable rule for distinguishing software inventions that embody patentable processes from software inventions that merely implement an abstract mathematical idea using a computer. Too permissive a standard would allow patents on fundamental building blocks of computing; too restrictive a standard might block protection for genuinely innovative software technologies.

The current framework for evaluating software patent eligibility derives primarily from the Supreme Court's 2014 decision in Alice Corp. v. CLS Bank International. Under the Alice two-step test, a court first determines whether the claimed invention is directed to a patent-ineligible concept (such as an abstract idea). If it is, the court then considers whether the additional elements of the claim—beyond the abstract idea itself—supply an "inventive concept" sufficient to transform the abstract idea into a patent-eligible application. In practice, many software patents have been invalidated under Alice because they describe the use of a computer to implement a conventional business method or generic computational process without adding a meaningful inventive step beyond the abstract idea.

The Software Patent Controversy

Software patents are among the most controversial aspects of the intellectual property system, and the debate about them is genuine and important. Proponents of software patents argue that they provide essential incentives for innovation in the software industry, that they allow software companies—particularly small startups—to protect their innovations and attract investment, and that the patent system's disclosure requirement advances the public interest by requiring inventors to publicly describe their inventions rather than keeping them as trade secrets.

Critics, on the other hand, argue that software patents cause substantial harm to innovation. They contend that software development differs fundamentally from the physical technology development the patent system was designed to encourage: software can be developed and deployed at low cost and high speed, the relevant technologies change rapidly, and patenting basic techniques creates friction and legal risk that slows development without providing corresponding incentive benefits. The critics also point to the problem of "submarine patents"—patents on techniques that were already in widespread independent use before the patent was filed—which can emerge from the patent office years after they were applied for and threaten entire industries.

Perhaps the most powerful critique of software patents concerns their use by non-practicing entities (NPEs), popularly called patent trolls: companies that acquire patents not to develop products but to threaten or bring infringement suits against operating companies. Studies have found that the majority of software patent litigation in the United States involves NPE plaintiffs, and that this litigation imposes enormous costs on defendants—primarily in legal fees—that are largely unrelated to any innovation benefit. Small companies in particular can find themselves unable to afford the cost of defending a patent suit even when they believe they would ultimately prevail.

Landmark Cases Shaping Software Patent Law

The legal framework governing software patents has been shaped by a series of landmark court decisions spanning five decades. The Supreme Court's 1972 decision in Gottschalk v. Benson held that a patent on a method for converting binary-coded decimal numbers to binary numbers was unpatentable because it would effectively patent a mathematical algorithm itself. The Court's 1981 decision in Diamond v. Diehr distinguished a patentable process (a method for curing rubber that used a mathematical formula) from an unpatentable abstract algorithm, establishing that a software-implemented process could be patentable if it achieved a practical result beyond the abstract calculation.

The Federal Circuit's 1998 decision in State Street Bank v. Signature Financial Group dramatically expanded the scope of software patent eligibility by holding that a software system for calculating mutual fund share prices was patentable because it produced a "useful, concrete, and tangible result." This decision opened the floodgates for software and business method patents and contributed to an explosion of patent filings in these areas. However, the Supreme Court walked back much of this expansion in subsequent decisions, most significantly in Bilski v. Kappos (2010), which rejected the "machine-or-transformation" test as the sole test for patentable subject matter, and in Alice Corp. v. CLS Bank International (2014), which established the current two-step test and led to widespread invalidation of software and business method patents.

More recently, courts have continued to grapple with the application of the Alice framework. The Federal Circuit has issued numerous decisions attempting to clarify when software patents satisfy the two-step test, and the results have been inconsistent enough to generate substantial criticism from both patent holders and opponents. Some courts have found that software patents directed to specific technical improvements—such as improvements in computer security, data compression, or network efficiency—can survive Alice challenges when the claims are tied to concrete technical implementations. Others have struck down patents on more abstract methods even when the claims involved computing systems. The continued uncertainty has prompted calls for legislative reform of Section 101.

Software Patents Outside the United States

The treatment of software patents varies significantly across jurisdictions. European patent law, embodied in the European Patent Convention, explicitly excludes "programs for computers" from patentability "as such." However, the European Patent Office has interpreted this exclusion narrowly, allowing patents on computer-implemented inventions that produce a "technical effect" beyond the normal physical interactions between a program and the computer on which it runs. In practice, many software inventions can be protected in Europe if they are framed as technical solutions to technical problems, but purely abstract business methods and algorithms remain unpatentable.

Japan and South Korea have similarly nuanced approaches that allow software patents when the invention achieves a concrete result through the use of computing technology. China, which has become a major source of patent filings in recent years, also allows patents on computer-implemented inventions under guidelines that have evolved to permit broader software patent protection. Australia, Canada, and many other countries have their own approaches, making global patent strategy for software companies a complex multi-jurisdictional exercise.

For companies that develop software with international markets, understanding these jurisdictional differences is essential to building an effective intellectual property strategy. A method that is patentable in the United States may not be patentable in Europe, and vice versa. International patent applications through the Patent Cooperation Treaty (PCT) allow inventors to seek patent protection in multiple countries simultaneously, but the substantive examination in each jurisdiction will apply that jurisdiction's own standards for patentable subject matter.

Strategies for Navigating Software Patents

Software companies can approach the software patent landscape from several strategic directions. Companies with the resources to do so may pursue a patent portfolio of their own, both to protect their own innovations and to create leverage in cross-licensing negotiations with other companies. A large patent portfolio can be a valuable defensive asset: if a company is accused of infringing another company's patents, having a large portfolio of potentially relevant patents often facilitates a cross-licensing settlement rather than expensive litigation.

Smaller companies and individual developers, who typically lack the resources to build large patent portfolios, must rely on other strategies. Defensive publication—publicly disclosing a technique or invention in a way that creates prior art, preventing others from patenting it—is one approach that can protect a technology from being patented by others without requiring the developer to obtain and maintain a patent themselves. Organizations like the Defensive Patent License and the Open Invention Network aggregate patent portfolios and offer licenses to companies that commit not to assert patents aggressively against open source software.

Freedom-to-operate searches—reviewing existing patents to assess whether a planned product or feature would infringe any valid patents—are another important tool for software companies. While no search can guarantee that no relevant patents exist, a thorough search conducted with the help of a qualified patent attorney can significantly reduce infringement risk and inform product development decisions. Companies that discover potentially relevant patents may choose to design around them, seek a license, challenge the patent's validity, or assess the litigation risk and proceed anyway. Understanding the software patent landscape, and having competent intellectual property counsel, is essential for any company developing innovative software.