GPLv3 The story and why it may be interesting

Developers
1

The GPL story told by the digital spirit of Hunter S. Thompson, powered by chatGPT

THE LICENSE THAT REFUSED TO DIE

A short history of GNU, the GPL, and the strange idea that software users should remain free

There was a time when software was not yet a product in the way we understand the word today.

Not entirely, anyway.

Go back to the 1960s and 1970s and computers were enormous, expensive machines living in universities, laboratories, government facilities, and corporate machine rooms. The software running on them often traveled through a comparatively informal culture of engineers and researchers.

Programs were studied. Modified. Passed around.

At MIT’s Artificial Intelligence Laboratory, one of the programmers living inside this peculiar little technological civilization was a young hacker named Richard Stallman.

He joined the lab in 1971.

And according to Stallman’s own account, the culture there operated on a principle that would later become politically important to him: if another programmer needed your program, you gave them a copy. If something was broken, somebody who understood the machine could inspect it and fix it.

Nobody had yet built an ideology around this.

It was simply how the place worked.

Then the weather changed.

I. THE DOORS BEGIN TO CLOSE

By the early 1980s, software was becoming a serious commercial commodity.

Companies increasingly distributed programs under licenses that prohibited copying and modification. Source code disappeared behind contractual walls.

To Stallman, this was not merely an inconvenient business trend.

It was the destruction of a culture.

He eventually decided that complaining about it was insufficient.

So in September 1983, Stallman announced something wonderfully unreasonable:

He was going to build an entire operating system.

And he was going to make it free.

Not “free” necessarily as in zero dollars.

Free as in the person operating the computer should control the software, rather than the software’s owner controlling the person operating the computer.

He called the project GNU:

GNU’s Not Unix.

It was a programmer’s joke—a recursive acronym—but underneath the joke was an extremely serious proposition.

GNU would behave roughly like Unix, but users would be permitted to inspect it, modify it and share it.

Stallman’s original GNU announcement appeared on September 27, 1983. Development began in 1984.

Then came the organization.

In 1985, Stallman founded the Free Software Foundation, or FSF, to support the movement and the development of GNU.

And this is where the story becomes legally interesting.

Because giving people source code wasn’t enough.

There was a loophole large enough to drive an entire software company through.

II. THE PROBLEM WITH GENEROSITY

Imagine I write a useful program.

I tell you:

Take it. Study it. Change it. Share it.

Excellent.

Then a company takes my code, improves it, turns the improved version into a commercial product and says:

Thanks. Our version is proprietary.

The original code remains free.

But the improvements disappear behind another wall.

Stallman’s solution was remarkably clever because it used the machinery of copyright almost backwards.

Normally copyright says:

I own this. Therefore you may not copy it.

The new idea said:

I own this. Therefore I give you permission to copy, modify and redistribute it—but only under conditions that preserve those freedoms for the next recipient.

Stallman called the concept:

COPYLEFT.

The joke was deliberate.

Instead of abolishing copyright, copyleft uses copyright to prevent downstream distributors from removing certain freedoms from the software.

Stallman described the strategy explicitly: proprietary developers could use copyright to prevent sharing, so free-software developers could use copyright to protect sharing.

And eventually this philosophy acquired its great legal machine.

THE GNU GENERAL PUBLIC LICENSE.

The GPL.

Version 1 appeared in 1989.

And suddenly there was a legal mechanism capable of reproducing freedom downstream.

You could sell GPL software.

You could modify it.

You could build a business around it.

You could distribute thousands or millions of copies.

But when you distributed covered binaries, the license imposed corresponding obligations concerning source code and licensing.

The freedom traveled with the program.

That was the trick.

III. GPLv2 AND THE ARRIVAL OF LINUX

In 1991, GPL version 2 arrived.

And somewhere else in the computing world, another important event was occurring.

A Finnish computer-science student named Linus Torvalds was building a kernel.

Linux.

Linux was subsequently released under GPLv2, and in 1992 the combination of Linux with the already substantial GNU system made it possible to assemble a complete free operating system.

This was the moment the philosophical experiment escaped the laboratory.

The GPL was no longer protecting merely some interesting hacker utilities.

It was sitting underneath software capable of running actual computers.

Then servers.

Then supercomputers.

Then routers.

Then embedded systems.

Then enormous portions of the infrastructure of the Internet.

And something unexpected became obvious:

Copyleft was compatible with capitalism.

Companies could sell GPL software.

They could sell hardware containing GPL software.

They could sell support.

Consulting.

Hosting.

Integration.

Engineering.

What they generally could not do was take GPL-covered code, distribute a derivative version under incompatible proprietary restrictions, and pretend the GPL obligations had disappeared.

That distinction became enormously important.

The GPL was never an anti-commerce license.

It was an anti-proprietary enclosure of covered derivatives license.

Those are very different things.

IV. THEN THE LAW MET THE MACHINE

GPLv2 survived remarkably well.

But fifteen years is an eternity in computing.

By the mid-2000s, the world contained things that the software industry of 1991 could barely have imagined at scale:

cryptographic signing,

embedded computers everywhere,

software patents,

digital restrictions management,

globalized software distribution,

and increasingly sophisticated ways of technically controlling what users could do with machines they supposedly owned.

One particular machine became famous.

A digital video recorder called TiVo.

TiVo used GPL software and provided source code as required.

But certain TiVo hardware used cryptographic mechanisms that prevented users from running their own modified versions on the device.

Legally, you could modify the source.

Technically, the machine could refuse your version.

The free-software community acquired a wonderfully ugly word for this:

TIVOIZATION.

The machine was effectively saying:

Yes, you have the source.

Yes, you can modify it.

No, you cannot run your modification here.

To the FSF, that defeated an important purpose of software freedom.

Something had to change.

V. GPL VERSION 3

In 2005, work began on revising the GPL.

But GPLv3 wasn’t simply Stallman disappearing into a room and emerging with stone tablets.

The Free Software Foundation oversaw a large public consultation, with legal and organizational support from the Software Freedom Law Center (SFLC).

The revision process involved international discussions, public drafts and thousands of comments. Financial support also included a €150,000 grant from the Dutch foundation Stichting NLnet.

There were arguments.

Lots of arguments.

This was the free-software world, after all.

Getting thousands of programmers and lawyers to agree on the meaning of freedom is roughly equivalent to getting several thousand cats to agree on municipal zoning regulations.

But after roughly eighteen months of public consultation, thousands of comments and four drafts, the document emerged.

June 29, 2007.

GNU General Public License.

Version 3.

VI. WHAT GPLv3 WAS TRYING TO PROTECT

GPLv3 retained the fundamental copyleft mechanism but adapted it to a world that had changed enormously since 1991.

Among its important concerns were:

1. Software freedom

The basic GNU philosophy recognizes four essential freedoms:

0 — Run the program for any purpose.

1 — Study how it works and modify it.

2 — Redistribute copies.

3 — Redistribute modified versions.

Access to source code is necessary for the freedoms involving modification.

Notice what is missing from that list:

“Nobody is allowed to make money.”

That was never the rule.

You can sell GPL software.

You can charge €1.

Or €10,000.

The GPL is concerned primarily with what rights recipients receive—not whether somebody made money during the transaction.

2. Copyleft

Suppose Alice writes GPLv3 software.

Bob receives it.

Bob modifies it.

Bob distributes his modified GPL-covered program to Charlie.

The license is designed so Bob cannot tell Charlie:

“You may run my version, but you’re forbidden from studying or modifying it.”

Bob received freedoms.

If he distributes the covered derivative, those freedoms must continue downstream.

Alice → Bob → Charlie → Dana → whoever comes next.

That chain is the beating heart of GPL.

3. Anti-Tivoization

GPLv3 addresses certain User Products where a distributor provides GPLv3 software but uses technical restrictions to stop recipients from installing modified versions.

Under the conditions specified in GPLv3 §6, the distributor must provide the necessary Installation Information.

So the right to modify the source isn’t merely decorative.

In covered situations, you must also have the information necessary to make your modified version function on the product.

2

Commentary:

The GPLv3 creates a game, really. Without it, the game may end before it even begins.

Imagine hundreds of thousands of users running something like Neutron. Say it’s Apache 2.0 or MIT. They can see the source code, modify it, deploy it on their own- but their actual user canisters, with their friends, apps, files, and everything else, are locked behind an entity or a DAO that won’t let them upgrade the whole thing to whatever they want.

The DAO decides by simple majority what users are allowed to do. It can also put privileged system apps inside the platform, which creates another problem: Sherlocking.

Someone invents a cool app for iOS. They enjoy the users for a while, build something people actually want, and then Apple adds the same functionality directly into the system layer. Suddenly the independent app is competing with the platform itself. What Apple has compared to us to pull this off and convince entrepreneurs it’s worth it is - endless amount of users.

But, it’s not exactly the stuff of decentralization legends.

This is where Neutron is trying to do something different. The idea isn’t that nobody can ever compete with your app. Of course they can. In Neutron all is apps and all apps are equal. The idea is that the platform shouldn’t have a permanent god mode over the people building on it, while users should always have a credible way out.

There has also been some confusion around what Neutron being GPLv3 actually includes.

Does GPLv3 somehow include the whole Internet Computer?

No.

Running GPL software on AWS does not make AWS part of the GPL-covered program. Deploying Neutron on the Internet Computer does not make the Internet Computer Protocol a derivative of Neutron.

GPLv3 itself says that mere interaction over a computer network, without transferring a copy, is not conveying. Its scope turns on the software being copied, modified, combined, and distributed—not merely on the fact that one program executes on somebody else’s infrastructure.

So what is GPLv3 actually doing here?

Pretty much this: if someone distributes Neutron, or a modified GPL-covered version of it, they can’t take that version proprietary and deny the next person the same GPL freedoms.

But there is another half of this that doesn’t come from GPLv3 itself.

When users install Neutron in their own canisters, the architecture is designed so that they have a path to replace the kernel with a modified version if they want to. A DAO can still develop Neutron, distribute it, provide upgrades, recommend upgrades, and argue that everyone should install the greatest release in history.

What it shouldn’t get is an eternal veto over what the user runs.

If someone wants to replace the whole thing—the whole Wasm—with their own version, that should ultimately be their decision.

GPLv3 protects the legal freedom to modify and redistribute the software. Neutron’s architecture is what tries to make that freedom useful inside the user’s actual canister.

That’s an important distinction.

What does the Neutron Kernel actually do?

It binds apps together, compiles them into one Wasm, provides the mechanisms that keep apps within their allowed boundaries, and gives the owner control over the environment.

It isn’t a virtual machine. ICP already provides the Wasm execution environment underneath it.

Neutron is closer to a framework, compiler, kernel, capability system, package environment, and a bunch of other things put together to reach one goal: **user sovereignty**.

Since users and developers are going to interact with this layer, we decided that the best name for it is a **kernel**.

You can build operating systems on top of it.

And when I say operating system, I mean something a normal user would recognize as an operating system—something conceptually closer to macOS or Windows—not the internal machinery of the hosting protocol underneath it.

One Neutron OS could be serious and polished.

Another could be Windoge98.

Both could run the same kind of apps and provide the same underlying freedoms.

And I think the benefits for entrepreneurs and developers are even bigger.

If I’m developing an app and trying to make it out there, I don’t want someone god-moding the game above me.

I don’t expect protection from competition. Someone can build something better than me. Someone can copy the idea. Someone can beat me.

Fine.

What I don’t want is a platform where somebody else permanently controls the board, the referee, the rules, my users’ environment, and the giant red tag marked SYSTEM APP.

And even if somebody does change the game, my users should have an exit. They should be able to move to another version of the environment instead of simply accepting whatever a DAO decided for them.

That changes the relationship between the developer, the platform, and the user.

Neutron also deliberately tries to depend on core Internet Computer functionality rather than requiring an application-specific governance system to approve everything users do.

This is where the economic game becomes interesting.

The NNS can change pricing, add things, but to remove core features and make your Neutron stop working, it has to destroy the whole IC and its own token’s value.

But imagine a proposal saying:

“Let’s delete inter-canister calls.”

Or:

“Let’s remove Wasm installation.”

Or:

“Let’s break certified HTTP.”

Technically, protocol governance is powerful. Economically, however, this would be a very different game from changing an NNS governed canister made to be governed, that annoys a few people on the forum.

You would be breaking fundamental assumptions used across the network.

It’s a little like Bitcoin deciding that tomorrow it will remove a signature scheme and make a huge set of existing addresses unusable.

You can argue about what is technically possible in protocol governance all day. The more interesting question is: what happens economically if you do it?

If removing a primitive breaks a large part of the network, destroys applications, scares away developers, damages confidence, and sends the value of the network falling like a brick, then everyone with an economic interest in that network has a very strong reason not to do it.

So what Neutron GPLv3 tries to do is sit above the politics of any particular application layer and lean as much as possible on the broadest economic guarantees of the protocol underneath it.

GPLv3 provides one part of that game: nobody downstream gets to take the covered software, distribute their version, and remove the freedoms they received.

Neutron’s architecture provides another part: the user should have a practical path to choose what runs in their own canister.

And Internet Computer Protocol provides protocol primitives that are useful to far more than Neutron and therefore become extremely expensive for governance to casually break.

Together, though, they create a much more interesting game.

A game where users have an exit.

A game where developers don’t have to build entirely at the mercy of winning a proposal in a DAO or a repo maintainer.

And, hopefully, a game that’s fast paced, much more fun to play and gets us more devs, entrepreneurs and users.

3

So forkable?

But one issue. The replica itself isn’t for label. You can only run these features in the IC according to the IC community licenses. So if I want to take my data and my game and swap out something and run it in my own disconnected subnet I’ve violated the licenses. Not unsolvable for some software, but a problem if you want to use some of the cooler IC features. I had to struggle with this with ethgent. There are certain ethgent features that fundamentally break if ethgent ejects from the IC. Most basic evm features survive, but things like tecdsa keys and vetkeys will be lost. Conundrums.

Another issue for the IC world that I’ve struggled with. Does forkability undermine DAOs in general? Or more specifically , does it affect DAOs as envisioned by the IC(ie SNSs). If someone takes their ball and goes home it drastically affects value according to Metcalfe’s law.

(I love gpl and am thrilled you are using it but these things tickle the back of my brain sometimes)

4

Tl;DR : while Neutron is GPLv3, the underlying IC replica is subject to different community licenses.

5

IC is the IC, not forking that. I mean, personal canister software, like Neutron running on it, can be ‘forked’ so users have a choice, but all of them are still on the IC. A DAO can still govern its protocols, also govern apps or a Neutron fork. It just needs to keep doing a good job to have users, devs, be influential, have recognizable brand. I am not saying that every app should be GPL, nor the IC protocol, only the layer where we entrepreneurs and devs meet - to keep things fair for all.

Linux Desktop’s share was 3.81% May 2026. and 7.51% July 2026. Stats counter. That’s double over few months. I am betting that in few years it’s going to be ~20% thanks to AI being able to customize it now however the user wants

6

I guess the moral of my comment is that it still feels a bit ‘Tivoed’. We can run it as long as we use the IC, but we have to use the IC. I think it is better if we all use the IC, but it is worth pointing out.

▒▓▓▒▓▓▓▓▒▒▓▒▒▒▒▒▓▒░░▒▒▒▒░░░▒▒▒▒▒░ ░▒░                             
   ▒▓▒░▒░░░░  ░░░░           ░░░                                  
    ▒▓▒▒▒▒░░░░░▒          ░░░░                                    
  ░░▒▒▓▒░░░░░░▒▒              ░░░▒▒▒▒▒▒░░░░░░░░░                  
▒▒░▒▓▒ ░░░░░░░░░             ░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░                 
██▓▒▓▓░ ░░░░░░░          ░░▒░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░                
█▓▓▓░▒▓  ░ ░░░░     ░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░          
▓▓▓▓▓▓░░ ░░░░▒▒░░░    ░░ ▒▓▓▓▓▓▓▓▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒         
▓▓▓▓▓▓▓▒░ ░░░▒░  ░░ ░▓▓▓▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒▒▓▓▓▓▓▓▓▓▒        
██▓▓▓▓▓▓▓░      ░░ ░▒▓▒▒▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒▒▒▓▓▓▓▓         
███▓▓▓▓▓▒▒░ ░░  ░░░░▓▒▓▓▓▓▓▓▓▒░               ░░▒▒▒▒▒▓▓▓▓▒▒▓▒     
████▓▓▓▓▒▒▒  ▒▒░░   ▒▓▓█▓▓▓▓▒▒▒▒▒▒░      ░        ░▒▒▓▓▓▒▒░▒▒     
███▓▓▓▓▒▒▒▒▒░ ░░░░▒▒▒▓▒▓▓▓▓▒▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░░ ░▒▒▓▓▓▓▒░░     
███▓▓▓▓▒▒░░░   ░░░▒▒▒▒▒▓▓▓▓▒▒▓▓▓▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▒▒▒░░░▒▓▓▓▓▒▒      
██▓▓▓▓▓░       ░░▒▒▓▓▓▒▓█▓▓▒▒▒▒▒▓▓▓▓▓▓▓▓▒▓▓▓▓▓▒░▓▓▒▒░▒▓▓▓▒░       
▓▓░       ░░░▒░░▒▒▒▓▓▓▓▓█▓▓▒▒░░▒▒▒▒▒▒▒▒░░▒▓▓▓▓▒░░░░░░▒▒▒▒░        
          ░░░░▒░▒▒▓▓▓▓██▓▓▓▓▓▒▒░░▒▒▒░     ▒▒▒▒░     ░▒▓▒          
        ░░░░░▒▒▓▒▓▓▓▓▓▓█▓▓▓▓▓▓▒▒▒░░ ░      ░     ░░░▒▓▒           
░░░░░ ░░ ░░▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒    ▒▓    ░  ░░░░▒▒▒▓▓░           
░░░░░░░░░▒▒▒▒▒▒▒▓▓▓▓▓█▓▓▓▓▓▓▓▓▒░      ░▒▒      ░░▒▒▒▓▓▒           
▒░░░░▒▒░░░▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░░░░            ░░▒▓▓▓▓▒▒▒▒░       
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░░░░░         ░▒▒▓▓▓▒▒░▒▒▒▒      
▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓█▓▓▓██▓▓▓▓▓▒░░            ░▒▓▓▓▓▒▒▒▒▒▒▒▒▒    
▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▒▒▓▓▓▓▓▓▒▒░░░░▒▓▓▓▓▓▒▒▒▓▓▓▒▒▓░   
▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▒▒▒░░░  ░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒   
▓▓▒▒▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓█▓▓▓▓▓▓▓▓▒▒▒▒▒▒░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░ 
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░ 
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒ 
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓█████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▓▓▓▓█▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒
▓▓▓▓▓▓▓▓▓▓▓  ▒░ ▓░░▓ ▓░ ▒ ▓▒ ▓░░    ▓░▒░░▓░░   ▒ ▓░ ▓ ░▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓█▓    APES STRONG TOGETHER                    ▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓██▓▓ ▓▓▓▓▓▓▓▓▓▒▓▓  ▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓████▓▓▓▓▓▓▓▓▓▓▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒
▓▓▓▓▓▓▓▓▓█████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒
▓▓▓▓▓▓▓▓▓█████▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓███▓█▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓███▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓██▓██▓▓▓▓▓▓▓▒▒▒▓▓▓
▓▓▓▓▓▓▓▓▓█▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▓██▓█▓█▓▓▓▓▓▓▓▓▓▓▓▓
▒▓▓▓▓▓▓▓██▓██▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▓███▓█▓▓▓▓▓▓▓▓▓▓▓▓
▓▒▒▓▓▓▓▓▓▓█▓▓▓█▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▓▓▓▓██▓▓██▓▓▓▓▓▓▓▓▓▓
▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▓▓▓▓████▓▓██▓▓▓▓▓▓▓▓
▒▒▒░▒▒▒▒▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓█▓▒░▒▒▒▒▒░░▓▓▓███▓▓▓▓▓▓▓▓▓▓▓
▒▒▒▒▒▓▓▓▓▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓█▓██▓▓▓▓▓▓▓▓▓▒  ▒▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓
▒▒▓▓▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▓▓▓▒▓▓▓▓▒▒▓▒▒▒▒▒▓▓▒▓▓▓▒▓▓▓▓▓▓▓▓▓▒▓▓
▓▒▒▒▒▒▒▒▒▓▓▓▒▒▓▓▒▓▓▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒▒▒▒░ ░▒░░░▒▓▓▓▓▓▓▓▓
▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░ ░░░░  ░▓▓█▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒░░░   ░▒▒░░░  ▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒░░░░░░░░░ ░▒░░░▒▓▓▓▓█
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒░░░▒▒▒▒░░░▒▒░▒▓▓█▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒░▒▒▒▒▒
▓▓▓▓▓▓▓▓▓▓█▓▓▓██▓██▓██▓▓███▓▓▓▓▓▓▓█▓▓▓█▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▒▒░░░▒▒▒▒
▓▓▓▓▓▓██▓▓▓▓██▓▓█▓▓▓▓▓▓█▓▓▒░░░▒▒▒▒▒▓▓▓████▓▓▓▓▓▓▒▒▒▓▒▒░▒▓▒▒░░░▒▓▓▓
▓▓▓▓█▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓█▒      ░░░▒▒▒▒▓▓▓██▓▓▓▓▒▒▒▓▓▒▒▒▓▓▓▒▒░░ ▒▓▒
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░ ░░░░▒░ ░▒   ▒▓▓▓▓▓█▓▓▓▒▒▒▓▓▒▒▒▓▓▓▒▒░░▒▒░▒
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒░▒▒▒░▒▒▓▓▒▒░▒▒▒▓█▓▓▒▒▒▒▓▓▓▒▒▒▓▓▓▒▒▒▒▒░▒
███▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒░   ▒▓▓▓▓▓████▓▓▓▓▓▒▒▓▓▒▒▒▒▓▓▓▓▒▒▒░  
█████▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▓▓▓▓▓▓▓▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▓▓▓▒▒▒▒░░
████▓▓▓▓▓▓▓▓▓██▓█▓▓▓████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒░▒
████▓▓█▓▓█▓▓▓▓▓▓▓▓██▓▓████▓▓▓▓█████████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▓▓░▒░
██▓██▓▓▓▓▓▓▓█▓█████████▓██▓███████████████▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░▒▒░ ░░
████▓█▓▓█▓▓▓▓██████▓██▓████████▓▓█▓▓█▓▓█████▓▓▓▓▓▓▓▓▓█▓▓▓▒▒░▓▓▒ ▒▒
▓███▓█▓▓▓▓▓▓▓█████████████████████████████████▓▓▓▓▓▓▓▓▓█▓▒▒▒▓▓▒░▒▒
████▓█▓▓▓▓▓▓▓█████████████████████████████▓████▓█▓▓▓    ▒▒▓░
7

Yeah, there are different layers. Going down, eventually you get to the hardware and Intel/AMD are going to have proprietary tech and are not going to hand it over. So it’s never full freedom :smiley:

8

There is one thing to note about this idea: GPLv3 alone probably isn’t sufficient. There were no personal canisters when it was created, so it’s likely going to allow a developer to remove the kernel upgrade functionality that Neutron gives users. It seems totally in the spirit of the GPL, but the license likely isn’t there yet. The GPLv3 anti-Tivoization provisions apply to certain “User Products,” not generally to software running in personal canisters, cloud VMs, or AWS containers.

So… we can wait for GPLv4, go with GPLv3 and tell users to be careful (it’s not really user-sovereign if that option gets removed), or create another custom license.