Note: This transcript is not a faithful reproduction of Panos’s live talk, but an edited version of his presentation. Many parts were rephrased to correct any inaccuracies and provide a more comfortable reading experience. The video of the original presentation can be found here:

Author’s note: This talk was presented at LibrePlanet 2022, about a year before the publication of this transcript. It contains introductory information to the problem of software patents, similar to our 2021 post. For more detailed and up to date information, please visit the ESP Wiki. If you would like to support our cause, please consider contributing to ESP Wiki or donating to the ESP campaign.

Stephen: I’m Stephen, the room monitor for this talk, titled “The state of software patents in 2022,” which will be presented by Panos Alevropoulos. Panos, among other things, is a volunteer member of the Free Software Foundation (FSF) Licensing & Compliance Lab, admin for End Software Patents (ESP) Wiki, and has a Creative Commons Certificate. Panos, welcome, and please proceed.

Panos: Thank you Stephen for the introduction. My name is Panos Alevropoulos. I studied law at the Aristotle University of Thessaloniki in Greece. I am also a former FSF intern, where I worked primarily on the ESP campaign, to which I continue to contribute as a volunteer. So, my topic for today is “The state of software patents in 2022.” It’s going to be an overview of software patents in 2022 along with some historical elements, and I will explain why software patents are unjust. I mean, you can probably tell that from the title of the campaign, but, to be more specific about what we are going to talk about today, here are the contents of my presentation:

  1. Introduction to software patents
  2. Why software patents are a threat
  3. The situation in the United States and Europe
  4. Non-solutions against software patents
  5. How to really End Software Patents
  6. Ways to achieve our goal

Introduction to software patents

To explain everything clearly, let’s start from the basics. This is going to be a legal presentation, but please bear with me. I will attempt to explain everything in simple terms. My goal is to make everything clear so that people can start discussing software patents. This is because they are really important, and they are sort of neglected compared to copyright.

First off, what is a patent? A patent is a legal tool that gives its owner the legal right to exclude others from making, using, or selling an invention for a limited period of time in exchange for publishing an enabling disclosure of the invention. Now, when we say for a “limited time,” we mean at least around twenty years. And for software, that is a long time. An “enabling disclosure” means that I have to file a patent application, then the patent office will accept my application and will grant the patent so that the public will have a document publicly available that explains all the technical details and how my invention works. The international requirement for inventions is that they should be new, involve an inventive step, and be capable of industrial application. These are general criteria that should apply to patents, and they may vary from country to country.

To understand patents, it’s also important to understand copyright. This way we can distinguish between the two. So, what is copyright? Copyright is an author’s exclusive right to copy and distribute a creative work, usually only for a limited time. The creative work may be in a literary, artistic, educational, or musical form (and this definition includes software). It applies to the original expression of an idea in the form of a creative work, but not the idea itself. So, free software licenses are essentially copyright licenses; they restrict the copyright terms and make everything more publicly available. But they don’t really work against software patents (at least not to the extent that we would like), so it’s essential to understand the difference between the two.

Right, so now that the difference between copyright and patents is clear, what is a software patent? Well, like the name suggests, it’s just a patent for software. But, it’s really not that simple, because it’s not evident that inventions should include software too… and that’s what we’re going to discuss today.

Here’s a table that shows an overview of the difference between copyright and patents.

DescriptionCreative work
(expression of an idea)
(methods and
TriggerApplied automaticallyMust be granted by a
patent office
LegalGoverns right to use,
copy, & distribute
Establishes a
market monopoly
DurationLife of the
author plus fifty or seventy years
At least
twenty years
Differences between copyright and patents

The main difference is that patents establish a market monopoly and they last for twenty years. Twenty years might not sound that long compared to the duration of copyright (life of the author plus fifty or seventy years), but it is, in fact, extremely long if one takes into account the restrictive nature of patents. Just imagine what twenty years mean for software: A software patent that was granted in 2002 would only expire in 2022. So many software technologies were invented during this time period, and they were all restricted by such a patent. This illustrates why patents in software are so restrictive.

Why software patents are a threat

So, let’s be more clear here: Why exactly are software patents a threat? Why do they present a danger for programmers and perhaps society itself? I have some arguments here that I will present to you one by one.

1. Blocking innovation: First of all, software patents block innovation. Patents can be very scary. When I’m writing a program, for example, I certainly don’t have any patents in mind and I can’t imagine that, in the future, I might be sued for something that I wrote myself. That concern only comes to mind if I’m copying code from someone else. But here’s what happens with patents: I can be sued even if everything was my idea simply because someone else in the world had the same idea, and they patented that idea. The funny thing is that, most likely, I would have had no idea that such patent existed; and that is for two reasons: The first, because patents are not easily found. I would have to search for patents all over the world just to find something that is close to my idea. The second reason is that some software patents are very obvious, and that’s a real problem because those shouldn’t have been patented in the first place.

2. Leading to extraordinary costs: Another problem is that software patents, like all patents, are really expensive. The problem with software is that most people, when they write programs, do it at home. It’s very cheap to write a program; there is almost zero cost for production. So, you can’t expect someone who writes programs for fun to have resources to face legal battles. To give an example, let’s just say that I’m a programmer and I’m trying to create a business out of my program, and, out of nowhere, Microsoft sues me because I infringed one of the thousands of software patents they own. It goes without saying that I almost certainly can’t afford litigation costs to fight Microsoft in court. This situation demonstrates why the patent system is particularly unjust in the software sector.

3. Harming freedom of expression: If you think about it, the restrictive nature of software patents effectively harms developers’ freedom to write code. It doesn’t matter if you are a free software developer or someone who writes proprietary programs; anyone who owns a software patent can, at any time, file a lawsuit against you for patent infringement.

4. Software progress doesn’t need patents: Patent advocates argue that patents provide a financial incentive, so the same should apply to software, right? Well, free software advocates have long argued that patents really haven’t contributed anything. There is no noticeable change between the pace of software progress before and after patents.

5. Software is math: Now, this is just a legal reason against software patents, but it’s actually very important when discussing patent eligibility. Simply put, in almost all countries, mathematics cannot be patented because they are considered to be a concept of nature. Software also falls into this category. Software code is a series of mathematical formulas so it’s algorithmic in nature. So, really, it all comes down to the fact that software is math, which is not patentable subject matter.

6. Software should be free: Finally, we, the free software community, strongly support that users should have the freedom to run, copy, modify, and distribute software. Patents are fundamentally against this philosophy. This might not be relevant to proprietary programs, but it demonstrates how patents affect free software beyond copyright.

Concluding this basic review, I hope you understand the core reasons to abolish software patents. The difference of the ESP campaign compared to other similar initiatives is that the FSF believes that only a legislative ban of software patents can be effective. There are really no other solutions that are good enough. I will be discussing this in more detail near the end of my presentation.

The situation in the United States and Europe

Just to give an overview of what’s going on in the world, I have chosen to present some details about the United States and Europe. Of course, there are other very important jurisdictions, like China, Japan, India, and basically every other country that accepts patents. But here’s the thing: both the American and the European patent systems are actually very influential to the world, such that other countries are very likely to borrow some trends and concepts that derive from these two systems.

Let’s start with the situation in the United States. First of all, it’s important to understand that software patents are not regulated via some sort of legislation, so the American patent system relies on case law. Although rare, it’s the US Supreme Court decisions that have the most impact on whether software patent applications are going to be granted or not. The most important decisions related to software patents are presented here:

Diamond v. Diehr (1981)Great, allowed software patents
Bilski v. Kappos (2010)Low, against software patents
Alice v. CLS Bank (2014)Great, against software patents, but not enough!
Important US Supreme Court decisions related to software patents

The most recent decision was Alice v. CLS Bank (aka “Alice“). The ruling brought a narrower interpretation on software patent eligibility, which is a good thing, but it was not enough. Sure, there was great progress since Alice and many patent applications on software were invalidated, but it does not mean that it’s impossible for someone to be granted a software patent. The Alice decisions made it harder for applications, but it didn’t change the fact that software patents are still issued.

Just to give an example, yesterday at LibrePlanet, Jarek Duda had a very interesting talk in which he described his personal experience. Jarek explained that, despite being the original author of a compression algorithm that was created years ago, other people, who were not involved in that process, have lately tried to register the very same work. Their persistence was successful. Just two months ago, Microsoft was granted a patent on that algorithm.

Okay, so like I mentioned before, software patents are not regulated. But this doesn’t mean that Alice cannot be overruled by legislation. In fact, law can always override previous court decisions, and in this case it can go both ways: It can explicitly say that software cannot be patented, and that would be great because that’s exactly what we want. On the other hand, it is certainly possible that Congress could be influenced, for example, by lobby groups to establish software as patentable subject matter. This would be terrible, because it would eliminate any possibility of narrow interpretation in the application process.

Let’s head over to Europe now. How do patents work in Europe? Basically, each country has its own patent law. However, since 1973, a multilateral treaty called the European Patent Convention (EPC) provided a supranational European autonomous legal system to which European patents are granted.

The EPC has a very specific provision on software patents, namely Article 52(2c)(3). This article specifies what should not be regarded as invention, and “programs for computers” are included in it. That sounds very good — it looks like software can’t be patented, right? Well, in reality, no, because there is another detail here: computer programs can be excluded from patentable subject matter only if they are considered to be “as such.” This wording is very vague and it’s not one-hundred percent clear what it means. The general meaning is that if computer programs are considered to have a further technical effect, then they should, in fact, be regarded as patentable subject matter. This “further technical effect” is open to interpretation, but the European Patent Office (EPO) has traditionally been particularly lax about it. This means that if the EPO is not reluctant to grant a software patent, it will always interpret Article 52(2c) broadly, as if the exclusion of computer programs never existed.

With that in mind, let’s take a look at some interesting recent developments. In 2013, the Unified Patent Court Agreement (UPC Agreement) was signed by most European Union (EU) member states. This treaty proposes a different system to the current European one.

European patentUnified Patent Court &
Unitary Patent
Contracting states
(not just EU member states)
Only EU member states
Unified patent applicationUnified patent application
Group of national patentsUnitary patent
Infringement cases handled
separately by national courts
Infringement cases handled
by the Unified Patent Court
Patent validity opposition handled
by the European Patent Office
and separately by national courts
Patent validity opposition handled
by the European Patent Office
and the Unified Patent Court
Comparison between European patent and Unified Patent Court & Unitary Patent

The way patent law works right now is that everything is a bit fragmented, so to say. If I want to file a patent application, I can file it to the EPO, but, if I am granted that patent, I won’t actually have a single patent, because a patent is actually a national instrument. So, the EPO grants a European patent, which is really a bundle of national patents. I will have a patent in Germany, Greece, Italy, and so on. This has a severe legal implication: if I believe someone infringed my patent rights, I would have to seek litigation in different countries, which can be very expensive. The worst case scenario is that the different national courts will have opposite decisions on the same legal case. For example, the German court can decide that there was patent infringement, but the Polish court can decide that there was no patent infringement.

All of that is going to change now thanks to the Unified Patent Court and the Unitary Patent*. From now on, in the EU, apart from the unified patent application provided by the EPO that existed already, the resulting patent is going to be Unitary and litigation will be handled by an independent Unified Patent Court, not just by national courts.

The Unified Patent Court and the Unitary Patent were actually two separate proposals, but are directly linked together. There was a lot of discussion and legal battles around them. In fact, although they were signed about ten years ago, it has taken many years to become a reality because they had to first be approved by national governments. The Unified Patent Court is currently still being set up to this day.

So, why is this all relevant to software patents? Well, it’s extremely relevant, because what saved us from some software patents in Europe was the fragmented process of enforcing patent rights throughout different countries, which was very expensive for patent holders. A supranational patent system such as the UPC Agreement is going to be much more effective for people seeking to register patents. The process for enforcing software patents will be more direct and faster. This is the first reason.

The second reason is that there is a very high probability that the Unified Patent Court will have a pro-software-patent bias. Let’s not forget that these initiatives are fueled by people who have a vested interest in expanding patents’ dominance, and that includes software patents. The Unified Patent Court will be independent of all EU institutions, so it will almost certainly be populated by biased judges, like former patent attorneys. This is bad news for us, because it means it is very likely that many software patents will be upheld as valid.

Non-solutions against software patents

We are now at the most crucial part of the presentation. How do we deal with all the problems that software patents cause? The free software community has discussed this issue for many years, but there are not many effective solutions. I will now present some attempts that have been made against software patents, which I call non-solutions, because they don’t completely solve the problem.

1. Invalidating harmful software patents: This, of course, is very beneficial. We always want to reject as many software patents as possible. To give an example, there was a presentation by the GNOME Foundation at last year’s LibrePlanet, who described their experience with a patent troll. “Patent trolls” are companies that acquire patents for the sole purpose of suing other developers. So, the GNOME Foundation was sued because their program Shotwell allegedly infringed a general software patent (which shouldn’t have been granted in the first place). The GNOME Foundation sought the invalidation of the patent; the case ended in a settlement.

The Shotwell case was fortunately handled by pro bono lawyers on behalf of the GNOME Foundation. But the free software community cannot always rely on pro bono attorneys for its protection. Right now, the patent system is basically a cat and mouse game for companies that have all the resources required to sue each other ad nauseam. This means that we have a permanent disadvantage; we will never have the resources to invalidate every single software patent or protect ourselves against lawsuits. For every single software patent we reject, dozens of others are granted. This is not sustainable.

2. Defensive patent acquisition / pools: For the same reason that relying on pro bono counsel is unsustainable, acquiring software patents ourselves and then granting full patent rights also doesn’t work in the long term. I mean, I posed this question to Jarek Duda yesterday (during his LibrePlanet talk’s Q&A session), and he simply replied that “sure, I could have acquired a patent myself, but 1. the process for that is too expensive, and 2. people can always patent other variants of my work.” This just shows how ineffective the patent system is. Patent law requires that there should be “no prior art” for a patent to be granted. “Prior art” means any previous known and published work related to the invention, and it doesn’t matter if it was patented or not.

Patent pools are a similar idea, except it’s not one entity but groups of people who form an alliance and acquire patents collectively. The goal of defensive patent pools is to reduce the harm of software patents to all or to a specific group of software developers, like the free software community.

3. Case law against software patents: This is also neither an easy nor an effective solution. Positive court decisions on software patents do have a considerable impact, like Alice in the US for example, but case law is not as definitive as legislation. At the end of the day, it doesn’t matter if there are many or few software patents, because the threat persists. This is why we need a law that bans software patents.

4. Raising examination standards: Okay, if the patent system is so broken, why don’t we try to fix it or at least make it better? Let’s, for example, make patent offices work harder, develop a better database on prior art, and make less frequent mistakes. This would decrease the number of harmful patents and increase the number of quality patents, right? Well, yes, that sounds good, but the problem is still there: People can still sue us for infringing software patents. The FSF doesn’t believe in just software patents and doesn’t distinguish between good or bad software patents. The very nature of patents is fundamentally against the free software philosophy, and that’s why we reject them altogether.

5. Patent clauses in free software licenses: Some software licenses, like the General Public License (GPL), include patent clauses. A patent clause is basically a provision in the license text that requires distributors of the program to give recipients permission to use any necessary patents. The general effect of such clauses is that they revoke any patent rights received through the license. Patent clauses only apply to patent holders who distribute the program under the license, so they are certainly not universal. They limit the effect of software patents, but don’t deal with them completely.

How to really End Software Patents

We already discussed non-solutions; so how do we really end software patents? Actually, let me be clear first: I call them “non-solutions,” but it’s very good that they exist! If there wasn’t any kind of protection against software patents, the situation would be far worse. So, yes, the end goal is to abolish software patents, but we will never say that non-solutions are bad or useless. They are very welcome, but we should always keep in mind that they don’t offer a complete solution.

So, finally, we will discuss ways to accomplish the abolition of patents.

1. Legislative ban on software patents: First of all, the best scenario is to have a law that explicitly says that software patents are illegal. The process would have to be done individually in every single country. This sounds very hard, but we should work towards this goal.

2. Shield software from litigation: Another solution, proposed by Richard Stallman, is to shield software from litigation. What this means is that we would accept software patents to exist, but we would effectively make them have no real effect. Such a law would accept software as patentable subject matter but would explicitly provide that developing, distributing, or running a program on any computer hardware would not, in any case, constitute patent infringement. This would eradicate all problems stemming from software patents.

3. Increase democratic processes: In general, patent laws and policies have been set without direct input from citizens. If we increase democratic processes and make people aware of the harm of software patents, we will maximize the chances of getting them repealed by legislation.

4. Ban all patents: A lot of people have argued that the whole patent system doesn’t provide any benefit. This sounds radical, but also sensible if we think about all the problems. The FSF and the ESP campaign can’t really talk about other types of patents, because our focus is software and nothing else. But we can’t deny that banning all patents would mean no software patents.

Ways to achieve our goal

We have presented our end goal, which is to end software patents. Now, we can talk about the steps required to achieve it.

1. Spread the word, write articles, be active! Software patents are an important issue and we need to make our voice heard. We should work to stop it from being a neglected topic.

2. Educate (use tools such as ESP Wiki): We need to educate people to make them understand what software patents are and why they pose a threat. We can use tools such as the ESP Wiki, which is an international database for campaign material against software patents.

3. Donate to organizations (FSF, EFF, SFC, SFLC): Campaigning needs financial resources, so we need all the help we can get.

4. Fuel local efforts to influence policies: Please don’t be afraid to talk about software patents to local politicians. An organized effort against software patents should be created in all countries.

5. Contribute to ESP Wiki (very much needed!) I will conclude my talk with an open call for help to the ESP Wiki. We invite people to contribute to it with any information they can find on software patents. A complete database against software patents will make international coordination more effective.

Thank you!

That’s it. I hope you enjoyed my talk. I know it’s a hard topic to grasp, and I hope I didn’t speak too much legalese. I tried to include as much information as I could and explain it in simple terms. If you have any issues, I am happy to answer them.


Stephen: Thank you, Panos. There was a question that came up in the chat: “What’s the problem with the software license revoking patents? Why is it a non-solution?”

Panos: The problem is that patent clauses in free software licenses have a limited effect. They basically concern only distributors of the program who have patent rights. The patent clause will just guarantee that these rights won’t be exercised at all. It’s a non-solution because it doesn’t involve banning software patents. It’s good to have them, and the GPL has one, but it’s not enough. We need to have laws that abolish software patents.

Stephen: Someone says that there wasn’t much legalese, so thank you for that. It was easy to follow. Another question: “Outside of software, are software patents, as ‘enabling disclosures,’ basically source code for material inventions?”

Panos: “Outside of software” … I’m not sure what that means, because we’re talking about software patents… (laughs). But when we say “enabling disclosure,” no, we are actually not talking about source code. If you take a look at some patents, they explain in detail the technical processes and methods that are used to create the end result: the invention. But it’s very broad, and the explanation that is included in the document can be used against so many programs, which is a real threat.

Stephen: “In what area is help needed on the ESP Wiki? Proposing legislation? Use cases? Or the existing laws or lawsuits?”

Panos: Actually, we need help with everything! Please just browse the Wiki, we have multiple links. We have some links for communicating, so we are still organizing. We need teams that will document everything, so that we can have a comprehensive database on software patents. For example, some content on the wiki needs to be updated, but it would be also useful to document some patents to illustrate the problem better.

Stephen: Okay, thank you. A follow-up question: “So, does the free software license patent clause make the software user immune from patent litigation? That sounds pretty useful on its own, I think.”

Panos: Does it make the user immune… I will be honest, I haven’t actually encountered any real life examples, so I would need to research this further, but I’m pretty sure immunity is not a real thing. Patent clauses can provide some sort of protection, though, for sure. Of course, ESP Wiki is there for exactly this reason; to answer this kind of question.

Stephen: There’s a little tiny bit of time left here, so here’s a good one: “Can we make a patent on making software patents, then enforce it to kill all other software patents? ;)

Panos: That would be great, actually… (both laugh). If we could do that, it would be the ideal world. I see your point, Ian.

Stephen: I think we’re all out of time. If you have access to the chat, I may have missed a couple things you may want to follow up on, but thank you again for a very comprehensive look at this, and we appreciate it very much.

Panos: Thank you very much! Do I have some time? There’s just one question that came up now.

Stephen: I think we might be out of time… actually, no. Okay, go ahead.

Panos: Okay. There’s a question here that says: “Will the European Court of Justice (ECJ) in the EU have a say about software patents?” I think the question is related to the new scheme, with the Unified Patent Court. I think the answer is no. There is actually no direct involvement of the ECJ, and what will actually happen is that the Unified Patent Court will only be able to present questions to the ECJ. So, there’s some involvement, but I don’t think it can overrule the decisions of the Unified Patent Court. We will have to see how this will turn out in practice.

Stephen: Okay. Thanks again!

Panos: Thank you very much!

Stephen: Goodbye!

Panos: Goodbye!

* The Unified Patent Court is scheduled to start its operations on June 1, 2023.