When Did GNU Become Linux?

James North Sep 28, 2023 Linux, Open Source Software, Programming, Free Software 0 comments

The image above is by the Free Software Foundation, and is made available under a CC-BY SA license.

This article was written by James North and is made available under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. Share it and build on it, but don't exploit it for commercial purposes.

Read the legalcode for the full terms.

When Did GNU Become Linux?

The GNU Project was started in 1983. Today is the 40th anniversary of the first public announcement of GNU. If you aren't familiar with the project, their goal was simple, if highly ambitious. It was to "create an operating system composed of entirely free software". Today, we have several options for completely free operating systems, like GNU Guix, PureOS, and Hyperbola.

But we don't call these operating systems "GNU"—aside from GNU Guix, anyway. We call them "Linux". Why is that? When did we go from The GNU Operating System to Linux?

Let me take you through the history, one step at a time.

Development of The GNU Operating System

When the GNU Project was announced in 1983, Richard Stallman (the founder) predicted the operating system would be complete within two years:

I think I'll have the compiler finished in a month or two. The only other large piece of work I really have to do is in the kernel. I first predicted GNU would take something like two years, but it has now been two and a half years and I'm still not finished. Part of the reason for the delay is that I spent a lot of time working on one compiler that turned out to be a dead end. I had to rewrite it completely. Another reason is that I spent so much time on GNU EMACS. I originally thought I wouldn't have to do that at all.

Richard Stallman, 1986 BYTE Interview

As it turns out, building an operating system is hard, and it takes a lot of work. There are a lot of parts to it. But Richard felt like the project was close to completion. The only major thing left was...the kernel. Now, before you jump ahead and tell me how the story ends, let's dig a little deeper.

Being Practical

Why did Richard spend so much time on GNU Emacs, which many of you will consider a glorified text editor, when he was supposed to be building an entire operating system? As it turns out, GNU Emacs was the most popular software Richard had ever written. It was available on several operating systems including UNIX, the most popular operating system at the time. Programmers would pay Richard to mail them a copy of GNU Emacs.

Richard's main source of income at this time was through consulting and GNU Emacs. Richard needed a lot of money to hire programmers to work on the GNU Project; he wasn't just building it himself. It would take far too long that way. GNU Emacs was also a good platform for showing what free software is capable of. So, his time investment in GNU Emacs was quite important to the development of the operating system in a practical way.

The development philosophy of the GNU Project was very practical. The greatest advantage of free software is that you don't need to re-invent the wheel every time you write some new software; if that software already exists, you can modify it for your needs. For instance, Richard didn't intend on writing a new compiler originally. He wanted to obtain a compiler written by someone else under a free license that he could include with the GNU Project. However, the developer of that compiler did not want to make it available under a free license, so Richard was forced to write his own. Today, that C Compiler has become the GNU Compiler Collection, and is among the most successful software under the GNU Project umbrella.

In the same way, Richard did not originally intend to create a kernel entirely from scratch. The GNU Project wanted the Mach microkernel from Carnegie Mellon University, which was not initially released under a free license in 1985, but they promised it would be within a few years. It seemed like a waste of time to start their own microkernel project when they would have something substantial to work with in a few years. In the meantime, they could polish other parts of the operating system.

As is well-known, the microkernel architecture never worked out even when the GNU Project was finally able to use Mach. The microkernel vs. monolithic kernel debate was a heated one at that time. It would make sense for the GNU Project to want to future-proof their design so it could easily adapt to future workloads. Unfortunately, this misguided decision cost them not only in years of development time, but in a much more fundamental way.

In a Galaxy Far Far Away, a Kernel is Born...

Many of you will know Linus Torvalds, the creator of the Linux kernel. Out of a desire to use UNIX on his home computer without paying a $20,000 license fee, he installed MINIX, a small UNIX-like operating system. Eventually, he started writing his own kernel that would offer him a few more features than MINIX, available for free (there was a fee to obtain a MINIX license at the time, but it is now free software). When he first released the kernel, it wasn't available under a free software license. While including the source code was a requirement, you were not allowed to charge money for Linux. It didn't matter whether that included shipping costs; you couldn't charge for it, period.

This is not a free software license. You can charge as little or as much as you want for free software, including making it available for free. While it's commendable that Linus wanted even the poorest students to be able to work with his software, preventing commercial distribution of Linux would have prevented companies like Red Hat from springing up. Linux wouldn't have been as successful as it is today without permitting commercial distribution. Linus later re-licensed the kernel under the GNU General Public License, which permitted selling the kernel. The kernel being free was always more important to Linus than the code being free, although he felt that was important too.

Linus was also practical. It's why the kernel used Bitkeeper as its version control system (VCS) for so many years—it was among the only VCS that could handle the scale of the kernel. Just like the GNU Project, that decision would turn out poorly for the kernel, but they rose above that challenge in an unquestionably graceful and praiseworthy way. Would we have git without Bitkeeper today?

You can see there is a small, but significant split between how Linus views software, and how the GNU Project views software. However, they both agreed on the general principles well enough to release their own software under the same license. Linus doesn't share the GNU Project's opinion that all software should be free. Linus generally releases his own software under a free license, and believes anyone making modifications to his software should be obligated to share those changes. It's an incredibly practical perspective.

From the very beginning, the kernel was bundled together with other software—namely, bash and gcc. Instead of writing these utilities himself, much like the GNU Project, Linus relied on third-party software.

Apart, neither the GNU Project nor the Linux kernel were an operating system. But GNU and Linux together made a usable operating system—finally!

Mission Accomplished. Pack it in.

The GNU Project had finally achieved their mission of creating a completely free operating system. There was still plenty of work to do to fully replace UNIX, but it was a hell of a start. The GNU Operating System was finally here.

Or...was it?

Neither The GNU Project nor Linus Torvalds had created an operating system. They had created parts of an operating system that could be used to build a complete operating system. At this point, neither of them were really distributing an operating system.

Softlanding Linux System (SLS) was the first major operating system that included Linux, GNU utilities, and the X Window System as a GUI. It used "Linux" in the name...not GNU. But before being Linux or GNU, it was the Softlanding System.

Shortly after SLS, we got Yggdrasil Linux/GNU/X (yes, that's the actual name they used), the first distribution put together by a commercial company. As you can imagine, the Linux/GNU/X name is rather unwiedly, so they shortened it to LGX. The company behind Yggdrasil also published The Linux Bible: The GNU Testament.

From here, we see a lot of operating systems that include GNU, Linux, X Window System, and plenty of other software others have created. Notably, we see Debian GNU/Linux, which was financially backed by the Free Software Foundation (parent organisation of the GNU Project). Not everybody was happy with the way these operating systems were named.

Giving the Linus Torvalds Award to the Free Software Foundation is sort of like giving the Han Solo Award to the Rebel Fleet.

Richard Stallman, Linuxworld, 1999

It's at this point we get to the GNU/Linux Naming Controversy.

What's in a Name?

In 1996, there is a heated debate between Richard Stallman, chief GNUisance of the GNU Project, and other members of the free software community. Linus mostly keeps out of it until it bleeds into regular discussions about Linux in 1996.

Umm, this discussion has gone on quite long enough, thank you very much.

It doesn't really matter what people call Linux, as long as credit is given where credit is due (on both sides). Personally, I'll very much continue to call it "Linux", but there have already been distributions that call it "Linux Pro(tm)" etc, which I don't find all that surprising..

The GNU people tried calling it GNU/Linux, and that's ok. It's certainly no worse a name than "Linux Pro" or "Red Hat Linux" or "Slackware Linux" (the last two are often just called "Red Hat" and "Slackware" when talking among Linux people, so there the "Linux" part has fallen off altogether).

Lignux is just a punny name - I think Linux/GNU or GNU/Linux is a bit more "professional" myself, but I'm not going to get gray hairs about this.

Much worse than the strange name is all the silly newsgroup and email activity this has resulted in. It's not as if the FSF unilaterally changed the name of the OS - they just changed the name of their "distribution".

Linus Torvalds, 1996 comp.os.linux.misc Newsgroup Discussion (Lignux, what's the matter with you people?)

Of course, this doesn't stop the discussion (sorry Linus), but it does bring up a key point—credit. Linus deserves credit for Linux. The GNU Project deserves credit for gcc, bash, GNU Emacs, and many other software packages. Simple, right? Well, not so much.

The GNU Project actually wanted credit for the entire operating system. If you think of it from their perspective, this made sense. They set out to develop an operating system in 1983 called GNU, and now they have several as a direct result of their years of hard work. Why shouldn't these operating systems be called "GNU"? They were creating an operating system called GNU, and suddenly people were referring to their work as "Linux".

The GNU Project wasn't saying that it was only their work that made this operating system possible. They acknowledge Linux is a very important part of the system and so "credit should be shared equally." This usually triggers a discussion about the significance of contributions and SLOC comparisons, which usually results in references to the X Window System, Wayland, Systemd, Freedesktop, GNOME, GTK, and many other important components of these operating systems today. Why should GNU, of all projects, get a mention when the others don't? And if you agree they're all important, then you should agree that they all need to be included in the name.

For practical reasons, we can't call it the GNOME/X/Freedesktop/Systemd/GNU/Linux system. That's way too wordy! For similar reasons, the GNU Project discussed why the advertising clause in the original BSD License was a bad idea.

It said that every advertisement mentioning the software must include a particular sentence:

3. All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by the University of California, Berkeley and its contributors.

When people put many such programs together in an operating system, the result is a serious problem. Imagine if a software system required 75 different sentences, each one naming a different author or group of authors. To advertise that, you would need a full-page ad.

GNU Project, The BSD License Problem by Richard Stallman

I think Seirdy makes the most effective argument in this vein. Namely, that Freedesktop software is the common denominator in the majority of distributions today, not GNU software—although the most common denominator is Linux. Most of these alternative system packages are used primarily for special scenarios; not for desktop operating systems. Ubuntu, Arch, Fedora, openSUSE, and many other mainstream distributions still use GNU packages.

Nonetheless, Linux had far more interest and momentum than GNU at this time. It quickly became the largest free software project in the world. Today, individual subsystems in the Linux kernel are bigger than most free software projects. To the people distributing these operating systems, the GNU Project was just a collection of utilities they could combine with Linux to make an operating system.

They didn't realize—or, if they did, they didn't care—that the GNU Project was an 8-year long project to build a free operating system. You can see why the GNU Project felt slighted, but it was more than that. As much as the Linux maintainers cared about free software, they weren't as stringent about it as the GNU Project. It's why Linux-Libre, a version of the Linux kernel without any proprietary firmware blobs, is maintained by the GNU Project today. The Linux maintainers were okay if it was "mostly" free, so long as it resulted in a better and more usable operating system, so in 1996, they started accepting firmware blobs in the kernel. Most users were happy for their devices to be more functional at the expense of their software freedom with regard to firmware.

The GNU Project was not happy about this.

If they were okay with including firmware blobs, it leads you to wonder what else they would be okay with. The timing of when Richard Stallman starts talking about "Lignux" and when the kernel started accepting proprietary blobs seems to intersect, but I don't know for sure. It wasn't the only issue. How about a proprietary graphics toolkit? Or what about proprietary graphical web browsers like Netscape Navigator? What was the point of a "free" operating system if significant parts of it were not free? This was a ruinous compromise the GNU Project did not want to make.

Somehow, the GNU Operating System had become the Linux operating system, and it was no longer a project for creating a completely free operating system.

The GNU Project viewed this state of affairs as coming from a place of not understanding the value of free software. They didn't think most users understood the operating system they were using was the result of 8 years of hard work building a free system. Their way of communicating that was to tell everyone to prefix "Linux" with "GNU".

While this discussion is partially about credit, it is really about philosophy. And Linux developers do not subscribe to all aspects of the GNU Project's philosophy. And that's fine! It's unrealistic to expect everyone who writes free software to have the exact same opinions on everything to do with free software. I certainly don't agree with GNU on everything.

Most people have never heard of GNU. Even most of the people who use the GNU system have never heard of GNU, since so many people and companies teach them to call it “Linux.”

Nonetheless, those who know about GNU associate it with the ideals of freedom of the free software movement. That association is no accident; the motive for developing GNU was specifically to make it possible to use a computer and have freedom.

A person seeing the name “GNU” for the first time in “GNU/Linux” won't immediately know what it represents, but has come one step closer to finding out. The association between the name GNU and our goals of freedom and social solidarity exists in the minds of hundreds of thousands of GNU/Linux users that do know about GNU.

Over time, calling the system “GNU/Linux” spreads awareness of the ideals of freedom for which we developed the GNU system.

Richard Stallman, GNU Users Who Have Never Heard of GNU

So, I think the GNU Project has a point. I also think this discussion is a complete distraction. The reality is incredibly simple. Richard Stallman doesn't get to dictate what you call your operating system just because it includes his or Linus Torvalds' software, regardless of the reasons they worked on it. It doesn't even matter if you've been working on an operating system for 13 years. The operating system vendor gets to decide the name. You can call it Red Hat Enterprise Linux, or you can call it UwUntu. If you're the Free Software Foundation, you can call it the GNU Operating System. Linus had it right the first time.

The situation might be different if the whole operating system was created by a single organisation, like FreeBSD or SerenityOS. If you took SerenityOS and added a few programs to it, it's still SerenityOS, but you can call it whatever you like when presenting it to your users. If someone points out that the system "is basically SerenityOS", it's hard to argue with that. Meanwhile, people will argue all day about whether the GNU system really is the GNU system as if we're discussing The Ship of Theseus. This is besides the point.

Let's acknowledge the work that goes into one of these distributions. Arch Linux, for instance, has developed a package manager, maintains and updates packages, and is responsible for distributing the operating system. It also decides what components to ship at the base level, like Systemd instead of runit. There's a lot of work that goes into that. And Arch tries to keep it simple! If you look at openSUSE or Fedora, the amount of duties they take on is much larger.

So, if anyone should get to decide what these operating systems are called, it should be the organisation responsible for managing the damn thing.

Open Source is Free Software, Didn't You Know?

There is...another side to this argument, however. Remember that split in opinion between the GNU Project and Linus Torvalds? It's why we have two terms which refer to essentially the same thing—"free software" and "open source". While it's easy to see where Richard Stallman is wrong about telling you what you're allowed to call your own operating system, "open source" is a much trickier beast.

Put simply, open source is about writing better software using the best software development methodology. Free software is about the users being in control of the software, not the developers. Quality is important, but not at the expense of the freedom to do what you want with the software. The most common misinterpretation of "free software" isn't as bad as the most common misinterpretation of "open source". At worst, free software can be interpreted to mean, "you don't have to pay anything for it." At worst, open source can be interpreted to mean, "you get to look at the code. Changing the code and redistributing it? That's a whole 'nother story."

This isn't hypothetical. Companies actually brand themselves as "open source" when the software they're distributing plainly doesn't meet the Open Source Definition. Do they not understand it themselves, or are they intentionally distorting the meaning? There are some people who believe businesses or individuals shouldn't be allowed to profit from open source software, which goes against the definition too. Overall, there is a lot of confusion about what exactly "open source" means. There was never this much confusion about free software. Tacky as it is, "free as in freedom, not free beer," is enough to set someone on the right path.

When people talk about open source, it's unclear to me what they actually mean. Do they mean it as the OSI intended, or are they using a personal definition? I think the GNU Project was completely right when they wrote Why Open Source Misses the Point of Free Software, and we should go back to calling it free software. It would be a lot less confusing for everyone. And...reminding people the GNU Project exists by referring to this family of operating systems as GNU/Linux is one way of getting those feelings across. This isn't a license to get into arguments about names, but it is a signal that declares very strongly what you care about.

So I think it can make sense to call this hurd of OSes GNU/Linux. Just the whole family, to be clear—each individual OS should not get "GNU" slapped in front of it unless the creators decide that.

It's important to realise, however, that the general public will never be convinced to call Linux "GNU" again. The battle has been lost. Even people who strongly believe in free software principles can't be convinced to call it that. Even people who have donated to the FSF, like John Carmack, don't call it that. You can only decide what you personally wish to call it.

Personally, I think saying "GNU/Linux" is a dumb way of communicating my feelings about free software, so I just call these operating systems "Linux". Or, if I'm feeling particularly pedantic, "Linux-based". I tried to use the name "GNU/Linux" for a while, but decades of flame wars have ensured I will never get the right message across. I'm taking the term "free software" with me to the grave, though.

How the FSF and GNU Help

The GNU Project hosts infrastructure for a lot of free software packages, big and small. There's GNU GRUB, GNU GCC, bash, GNU Guix, GNU Emacs, GIMP, GNU Hurd, Linux-libre, GPG, and glibc, but this also includes GNU Go, GNU Health, and Jami. There are a lot of cool projects here that have nothing to do with the server world. That isn't to say professionals don't work on these projects, because they absolutely do. The Free Software Community is interested in being a place welcoming to everyone.

The GNU Project isn't the only free software community around. There are others, big and small. There's the GNOME community, for instance. Or the KDE community. But the GNU Project (along with the Free Software Foundation) was the one that really started it all, and they are still campaigning for free software today. We owe a lot to that work.

Here are some of the campaigns which are important to me:

Defective by Design—DRM sucks. This campaign has a list of DRM-free media.
End Software Patents—This is a very important campaign. Software patents prohibit programmers frrom writing useful software which infringes on a patent, which has negative impacts on all of us except the patent holder. You can see an example of this in my other article about DaVinci Resolve.
Free BIOS—We've got a free operating system; now we need a free BIOS.
Fight to Repair—We should have the right to repair what we own. Some companies are making this needlessly difficult, prioritising profits before longevity. The only way we will get repairable technology is to fight for it. Also see fighttorepair.org.

I'm not going to call it UwUntu GNU/Linux, though. Happy 40th birthday, GNU, and thanks for all the penguins.