The GNU Project and free software

The GNU project is the reason a Linux server has a shell, a compiler, a C library and the hundred small commands you type all day. Richard Stallman announced it in September 1983 with one goal: a complete Unix-like operating system that anyone could use, study, change and share. By 1991 almost every piece was ready except the kernel, and that gap is where Linux came in.

In this lesson you’ll learn where GNU came from, what “free software” and copyleft mean, and why GNU never got a working kernel of its own. Then you’ll go hunting for GNU on rocky01 and ubu01, and you’ll find a surprise on Ubuntu 26.04 that many experienced admins haven’t noticed yet.

Where this lesson fits

Lesson 5 of 82 in Linux Administration · Phase 1: The origins and OS architecture · Before this: Lesson 4, Unix history · Next: Lesson 6, Linus Torvalds and the Linux kernel

TimeYou needBy the end you can
About 50 minutesrocky01 and ubu01 from Lesson 2, logged in as student over SSHName the GNU parts of a Linux system, read their licences and spot GNU-only behaviour before it breaks a script

What it is, in one line

The GNU Project is the effort, started by Richard Stallman in 1983, to write a complete free Unix-like operating system, and most of the tools you use on Linux today came out of it.

In Simple Words

Building a house with borrowed tools

Imagine a village where the only good set of carpentry tools belongs to one company. You may use them, but you can’t open them up to see how they work, you can’t sharpen them your own way and you can’t lend them to your neighbour. If the company changes the rules, your half-built house stays half-built.

One carpenter gets fed up and starts making his own set, hammer by hammer and saw by saw, and gives every tool away with one condition attached: whoever passes it on must pass on the freedom too. Other carpenters join in. Within a few years the village has every tool it needs except the big machine that drives the whole workshop.

The GNU tools are that set, and the missing machine was the kernel, which a student in Finland would supply in 1991.

Engineer's View

GNU in dates and parts

GNU stands for “GNU’s Not Unix”, a recursive joke that also states the design: it behaves like Unix but contains no Unix code. Stallman posted the announcement on 27 September 1983 to the net.unix-wizards and net.usoft newsgroups. He planned to start at Thanksgiving, but the work began in January 1984, when he left his job at the MIT AI Lab so that MIT could not claim the code.

WhenWhat happenedWhy an admin cares
27 Sep 1983GNU announced on UsenetThe start of the free software movement
Jan 1984Work starts; GNU Emacs follows in 1985The first big GNU program people used
Mar 1985The GNU Manifesto is publishedExplains the “why” behind the licences you still read
4 Oct 1985Free Software Foundation (FSF) founded in BostonHolds copyright on most GNU code and publishes the GPL
22 Mar 1987GCC 1.0 releasedEvery Linux kernel and distribution is still built with a compiler, usually GCC
1987Roland McGrath starts the GNU C Library (glibc)The layer between every program and the kernel
25 Feb 1989GPL version 1Copyleft written down as a licence
Jun 1989Brian Fox releases the first Bash betaThe default shell on RHEL and Ubuntu
Jun 1991GPL version 2The licence of the Linux kernel to this day
2003fileutils, sh-utils and textutils merge into coreutilsls, cp, mv, cat, df, chmod and about a hundred more
29 Jun 2007GPL version 3The licence of today’s bash, coreutils and gcc

“Free” here means freedom, not price. The FSF lists four freedoms, numbered from zero the way programmers count: run the program for any purpose (0), study and change it (1), share copies (2) and share your changed versions (3). Freedoms 1 and 3 need the source code, which is why the GPL insists on it.

Copyleft is the trick that keeps those freedoms alive. It uses copyright law the other way round: if you distribute a GPL program, or a changed version of it, you must give the people who receive it the source code under the same GPL terms. You can use GPL software inside your company as much as you like without publishing anything, because the duty starts when you hand the program to someone else.

Permissive licences such as MIT, BSD and Apache 2.0 allow free use too, but they don’t force changed versions to stay open. You’ll see both kinds side by side on your servers in the lab.

How it works, step by step

The GNU plan was a full operating system, written one piece at a time. The order mattered: you can’t build a C library without a compiler, and you can’t build anything without an editor and a debugger. The timeline below follows that path.

1Write the tools that build everything else

Emacs came first, so the team had an editor, then GCC, the debugger GDB, make and binutils (the assembler and linker). With a free compiler, every later piece could be built without paying anyone for a licence.

2Write the tools people type

Next came the shell (Bash), the file and text utilities (later merged into coreutils), grep, sed, gawk, tar, gzip and the rest. Developers ran these on top of commercial Unix systems such as SunOS, so GNU tools were in daily use long before there was a GNU system to run them on.

GNU project timeline from the 1983 announcement to the missing kernel

3Write the C library

glibc gives programs functions like printf() and open(), and turns those calls into system calls the kernel understands. It’s the reason the same program source can be built on many kernels and CPUs.

4Write the kernel last

The kernel was planned last, and it never caught up. A first attempt based on an MIT research system called TRIX was dropped in 1986. In 1987 Stallman chose the Mach microkernel from Carnegie Mellon University, but waited about three years for it to be released under a usable licence, so work on the GNU Hurd (a set of servers running on top of Mach) only started in 1990.

5Why the Hurd lost the race

A microkernel keeps the core tiny and runs file systems, networking and drivers as separate programs that send each other messages. That is elegant and safer in theory, but much harder to debug, and Stallman later said the choice cost GNU many years. When Linux arrived in 1991 as a simple monolithic kernel that already worked with the GNU tools, most volunteers moved to it.

The Hurd still exists (Debian GNU/Hurd 2025 came out in August 2025), but nobody runs it in production.

The picture underneath shows what that means on rocky01 today. Everything above the kernel line is mostly GNU, and the kernel itself is Linux.

GNU project parts on a Linux server: commands, bash, gcc, glibc above the Linux kernel

This is why the Free Software Foundation asks people to say “GNU/Linux” for the whole system, and why Debian calls itself Debian GNU/Linux. Lesson 6 covers that naming argument from both sides. For your daily work the useful habit is simpler: when a command behaves oddly, ask which project wrote it and which version you have, because the answer is not always GNU any more.

Ubuntu 26.04 is the clearest example. Its core utilities now come from uutils, a rewrite in Rust under the MIT licence, while GNU coreutils stays installed beside it. RHEL 10, Rocky Linux 10 and Oracle Linux 10 still ship GNU coreutils 9.5.

Alpine Linux, which you’ll meet in containers, uses BusyBox and musl instead of GNU coreutils and glibc. Same commands on the screen, different code underneath.

Hands-on lab: find the GNU inside your Linux servers

Before you run any command, double-check it

Read every command twice before you press Enter. Check the target: the server name, the user, the disk or device name, the path and the sizes. These commands are for learning and were tested in our lab, not on your system. At work, run the read-only commands first, follow your change process, make sure a backup exists, and ask a second person to check anything that changes or deletes data. You run them at your own risk.

In this lab you’ll go looking for GNU on both lab servers: ask each tool who wrote it, find the package it came from, read its licence and compile a tiny program with GCC. Everything is read-only except two package installs and one small folder in your home directory.

Log in to both VMs from your laptop: ssh -p 2211 student@127.0.0.1 for rocky01 and ssh -p 2221 student@127.0.0.1 for ubu01. Your version numbers may be a little newer than the ones shown here if you’ve installed updates.

1Ask the shell who made it

Run this on rocky01:

bash --version

You should see something like this:

GNU bash, version 5.2.26(1)-release (x86_64-redhat-linux-gnu)
Copyright (C) 2022 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>

This is free software; you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Bash is a GNU program, and the second line names the Free Software Foundation as the copyright holder. The licence line says GPLv3 “or later”. On ubu01 the same command shows a newer Bash:

GNU bash, version 5.3.9(1)-release (x86_64-pc-linux-gnu)
Copyright (C) 2025 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>

This is free software; you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

The part in brackets is the build target. x86_64-redhat-linux-gnu and x86_64-pc-linux-gnu both end in “linux-gnu”: a Linux kernel with the GNU C library on top.

✅ Checkpoint: You can read the Bash version on both servers and say who holds its copyright.

2Ask ls who wrote it, on rocky01

Run this on rocky01:

ls --version

You should see something like this:

ls (GNU coreutils) 9.5
Copyright (C) 2024 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Written by Richard M. Stallman and David MacKenzie.

Almost every GNU program answers --version and --help the same way, which is one of the GNU coding standards. The last line is a little piece of history: Stallman wrote the first GNU ls himself.

✅ Checkpoint: rocky01 reports ls (GNU coreutils) 9.5 or a newer 9.x.

GNU project lab output on Ubuntu 26.04 showing uutils and GNU coreutils versions
Example output from ubu01 (Ubuntu 26.04). Your version numbers may differ.

3Which tools are GNU on Ubuntu 26.04?

Run this on ubu01:

ls --version

You should see this:

ls (uutils coreutils) 0.10.0

That isn’t GNU. Ubuntu 26.04 switched its core utilities to uutils, a Rust rewrite, but kept the GNU versions for the commands where the rewrite still had bugs. Check a handful at once.

Paste this whole block:

for c in ls cat cp mv rm df sort wc chmod; do
  printf "%-6s " "$c"; $c --version | head -n 1
done

You should see something like this:

ls     ls (uutils coreutils) 0.10.0
cat    cat (uutils coreutils) 0.10.0
cp     cp (GNU coreutils) 9.7
mv     mv (GNU coreutils) 9.7
rm     rm (GNU coreutils) 9.7
df     df (GNU coreutils) 9.7
sort   sort (uutils coreutils) 0.10.0
wc     wc (uutils coreutils) 0.10.0
chmod  chmod (uutils coreutils) 0.10.0

On a fresh 26.04 install before updates you may see uutils 0.8.0 instead of 0.10.0. The GNU originals are still there with a gnu prefix, and the normal names are only symbolic links:

gnuls --version | head -n 2
readlink -f /usr/bin/ls /usr/bin/cp

You should see this:

ls (GNU coreutils) 9.7
Packaged by Ubuntu (9.7-3ubuntu2.1)
/usr/lib/cargo/bin/coreutils/ls
/usr/bin/gnucp

✅ Checkpoint: You can name three commands on ubu01 that come from uutils and three that still come from GNU.

4Find the package behind a command

Run this on rocky01:

rpm -qf /usr/bin/ls
rpm -qi coreutils | grep -E '^(Name|Version|License|URL|Summary)'

You should see something like this:

coreutils-9.5-8.el10_2.1.x86_64
Name        : coreutils
Version     : 9.5
License     : GPL-3.0-or-later AND GFDL-1.3-no-invariants-or-later AND LGPL-2.1-or-later AND LGPL-3.0-or-later
URL         : https://www.gnu.org/software/coreutils/
Summary     : A set of basic GNU tools commonly used in shell scripts

rpm -qf answers “which package owns this file?” and rpm -qi prints the package’s details, including its licence in SPDX form (the short standard licence names). On ubu01 the Debian tools do the same job:

dpkg -S /usr/bin/ls
dpkg -l coreutils coreutils-from-uutils gnu-coreutils rust-coreutils | tail -n 6

You should see something like this:

coreutils-from-uutils: /usr/bin/ls
||/ Name                  Version                     Architecture Description
+++-=====================-===========================-============-==========================================
ii  coreutils             9.5-1ubuntu2+0.0.0~ubuntu25 all          coreutils meta package
ii  coreutils-from-uutils 0.0.0~ubuntu25              all          coreutils from the uutils project
ii  gnu-coreutils         9.7-3ubuntu2.1              amd64        GNU core utilities
ii  rust-coreutils        0.10.0-1ubuntu2~26.04.1     amd64        Universal coreutils utils, written in Rust

On Ubuntu, coreutils is now an empty “meta package” that pulls in one provider, coreutils-from-uutils by default. You’ll use rpm and dpkg properly in Lessons 35 and 36.

✅ Checkpoint: You can say which package owns /usr/bin/ls on each server.

5Read the licence that came with the code

Run this on rocky01:

ls /usr/share/licenses/bash /usr/share/licenses/coreutils-common
head -n 2 /usr/share/licenses/bash/COPYING

You should see something like this:

/usr/share/licenses/bash:
COPYING

/usr/share/licenses/coreutils-common:
COPYING
                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

RPM packages put licence files under /usr/share/licenses/<package> and other documents under /usr/share/doc/<package>. Debian and Ubuntu keep one machine-readable copyright file per package and the full common licence texts in /usr/share/common-licenses. Run this on ubu01:

grep -m1 '^License:' /usr/share/doc/bash/copyright /usr/share/doc/rust-coreutils/copyright
ls /usr/share/common-licenses

You should see something like this:

/usr/share/doc/bash/copyright:License: GPL-3+
/usr/share/doc/rust-coreutils/copyright:License: MIT
Apache-2.0  CC0-1.0   GFDL-1.3  GPL-2  LGPL-2    MPL-1.1
Artistic    GFDL      GPL       GPL-3  LGPL-2.1  MPL-2.0
BSD         GFDL-1.2  GPL-1     LGPL   LGPL-3

So the shell on ubu01 is copyleft (GPL-3+) and its ls is permissive (MIT). Both are free software, but only the first forces changed versions to stay open.

✅ Checkpoint: You found the licence files for bash on both servers.

6Try GNU long options

Run this on either server:

cd ~
ls -a
ls --all
ls -A
ls --almost-all

You should see something like this:

.  ..  .bash_history  .bash_logout  .bashrc  .cache  .profile
.  ..  .bash_history  .bash_logout  .bashrc  .cache  .profile
.bash_history  .bash_logout  .bashrc  .cache  .profile
.bash_history  .bash_logout  .bashrc  .cache  .profile

Classic Unix gave you short options: one dash and one letter. GNU added long options with two dashes and a readable name, so ls -A and ls --almost-all do the same thing. Long options make scripts easier to read six months later.

GNU programs also accept any unique start of a long option, so ls --alm works too, which leads straight into the first Break-It below.

✅ Checkpoint: You can give the long form of ls -a and ls -A.

7Build a program with GCC and glibc

Install the compiler. On rocky01:

sudo dnf install -y gcc

On ubu01:

sudo apt install -y gcc

Then, on ubu01 (rocky01 works the same way), paste this whole block:

gcc --version | head -n 1
mkdir -p ~/gnu-lab && cd ~/gnu-lab
cat > hello.c <<'EOF'
#include <stdio.h>

int main(void)
{
    printf("Hello from GNU tools\n");
    return 0;
}
EOF
gcc hello.c -o hello
./hello
ldd ./hello
ldd --version | head -n 1

You should see something like this:

gcc (Ubuntu 15.2.0-16ubuntu1) 15.2.0
Hello from GNU tools
	linux-vdso.so.1 (0x00007ffd4b3e2000)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f2a6c400000)
	/lib64/ld-linux-x86-64.so.2 (0x00007f2a6c6b1000)
ldd (Ubuntu GLIBC 2.43-2ubuntu2.4) 2.43

GCC turned your C file into a program, and ldd shows it depends on libc.so.6, which is glibc. On rocky01 you get GCC 14.3.1 and glibc 2.39 instead, but the same picture. Nearly every program on the server, from sshd to the package manager, sits on that same library.

✅ Checkpoint: Your hello program prints its line, and ldd shows libc.so.6 on both servers.

Break It, Then Fix It

Three real failures, all caused by the gap between “a command called ls” and “GNU ls”. None of them can hurt your VMs, so no snapshot is needed.

1Shorten a long option too far

Run this on rocky01:

ls --al

You’ll get this error:

ls: option '--al' is ambiguous; possibilities: '--all' '--almost-all'
Try 'ls --help' for more information.

GNU accepts a shortened long option only when exactly one option starts that way, and two do here. The uutils ls on ubu01 refuses it as well, with a different message, so a script that greps for the GNU wording won’t match:

error: unexpected argument '--al' found

tip: a similar argument exists: '--all'

Usage: ls [OPTION]... [FILE]...

For more information, try '--help'.

Fix: always type the full long option, in scripts above all.

ls --all

✅ Checkpoint: ls with the full option name works on both servers.

2Forget the header file

On ubu01, delete the first line of hello.c and compile again:

cd ~/gnu-lab
sed -i '1d' hello.c
gcc hello.c -o hello

You’ll get this error:

hello.c: In function ‘main’:
hello.c:4:5: error: implicit declaration of function ‘printf’ [-Wimplicit-function-declaration]
    4 |     printf("Hello from GNU tools\n");
      |     ^~~~~~
hello.c:1:1: note: include ‘<stdio.h>’ or provide a declaration of ‘printf’
  +++ |+#include <stdio.h>
    1 |
hello.c:4:5: warning: incompatible implicit declaration of built-in function ‘printf’ [-Wbuiltin-declaration-mismatch]

printf lives in glibc, and stdio.h is the header that tells the compiler what it looks like. Older GCC releases only warned about this, but since GCC 14 it’s an error, so old source code that “always compiled” can fail on RHEL 10 and Ubuntu 26.04. You’ll meet this when someone asks you to rebuild an old in-house tool.

Fix: put the include back and compile again:

sed -i '1i #include <stdio.h>' hello.c
gcc hello.c -o hello && ./hello

✅ Checkpoint: The program compiles and prints Hello from GNU tools again.

3A script that trusts GNU behaviour

Paste this whole block on rocky01, then the same block on ubu01:

cat > ~/gnu-lab/cpu-check.sh <<'EOF'
#!/bin/bash
if [ "$(uname -p)" = "x86_64" ]; then
  echo "64-bit Intel/AMD server, OK to install the agent"
else
  echo "Unsupported CPU: $(uname -p)" >&2
  exit 1
fi
EOF
bash ~/gnu-lab/cpu-check.sh

rocky01 says:

64-bit Intel/AMD server, OK to install the agent

ubu01 says:

Unsupported CPU: unknown

uname -p (processor type) isn’t defined by POSIX, and GNU itself prints “unknown” on Linux. Red Hat and Debian patch their GNU builds to print the machine type, so the check worked for years, until Ubuntu 26.04 switched to the uutils uname, which doesn’t carry that patch. Run gnuuname -p on ubu01 and you’ll see x86_64 again.

Fix: use the machine hardware name, which every implementation supports:

sed -i 's/uname -p/uname -m/g' ~/gnu-lab/cpu-check.sh
bash ~/gnu-lab/cpu-check.sh

✅ Checkpoint: The script prints the OK line on both servers.

This happened at work

The CDR files that came from nowhere

I was working with the billing team of a mobile operator in Toronto when they moved their nightly mediation jobs from an old RHEL 8 VM into small Alpine containers. The jobs collect call detail records (CDRs) from the network, rename them by date and hand them to billing. The move was tested on a Friday afternoon and went live on Monday night.

On Tuesday morning a billing analyst noticed that the previous day’s file was missing and a file called cdr_.csv had appeared instead, holding records from three different days. The first idea was a network problem, so someone spent an hour checking whether the collectors had sent everything. They had.

The cause was one line in the shell script: date -d '1 day ago' +%Y%m%d. That relative date is a GNU extension. Alpine uses BusyBox, whose date printed “invalid date” to stderr and nothing to stdout, and the script never checked the exit code, so the date part of the filename was empty.

The Friday test had run on a laptop with GNU coreutils, which is why nobody saw it.

The quick fix was apk add coreutils in the image, which brings in GNU date. The lasting changes were more useful: every script now starts with set -euo pipefail, the test runs inside the same container image that goes live, and the team keeps a short list of GNU-only options they had been using without knowing it.

Common mistakes and troubleshooting

MistakeWhat happensWhat to do instead
Thinking “free software” means “no cost”You miss the licence duties when the company ships software to customersRead it as freedom: run, study, change, share. Check the licence before you redistribute anything
Assuming every Linux has GNU coreutilsScripts fail on Ubuntu 26.04 (uutils) or Alpine (BusyBox) with odd errorsRun ls --version and test scripts on the same image they will run on
Shortening long options in scriptsAn option becomes ambiguous after an upgrade, or the other implementation rejects itType the full long option, such as --almost-all
Relying on non-POSIX output like uname -pThe script works on one distribution and fails on the nextUse portable options (uname -m) and check exit codes
Calling the GPL “viral” and banning all GPL toolsTeams avoid bash, gcc or rsync for no reasonInternal use creates no duty. Ask legal only when you distribute modified code
Looking for licences only in /usr/share/doc on RockyYou think the package has no licence fileRPM puts them in /usr/share/licenses/<package>; Debian uses /usr/share/doc/<package>/copyright

Interview questions

Click a question to open it. Each one is written the way an interviewer would ask it. Under it you will see why they ask it and one way you could answer, in your own words.

Fresher level

1. What is the GNU Project, and how is it related to Linux?

Why they ask this: They want to know you understand that a “Linux server” is more than the kernel. Mixing up the two is a common fresher mistake.

How you might answer: GNU is the project Richard Stallman started in 1983 to build a complete free Unix-like system. It produced bash, gcc, glibc, coreutils and most of the everyday tools.

Linux is the kernel Linus Torvalds wrote in 1991. A typical distribution like RHEL or Ubuntu is the Linux kernel with GNU tools and libraries on top, which is why the FSF calls it GNU/Linux.

2. What does “free software” mean, and what is copyleft?

Why they ask this: This checks whether you know free means freedom, and whether you can explain the GPL in plain words.

How you might answer: Free software gives you four freedoms: run it, study and change it, share it and share your changes. It’s about freedom, not price.

Copyleft is how the GPL protects that. If I distribute a GPL program or a changed version, I have to give the source code to whoever gets it, under the same licence. Using it inside the company doesn’t trigger that duty.

2–5 years experience

3. A shell script works on RHEL 9 but fails on an Ubuntu 26.04 server. How would you start?

Why they ask this: They want to see that you check which implementation of a command is running before you blame the script logic.

How you might answer: First I’d run the failing commands with --version. On 26.04 most coreutils commands are uutils, not GNU, and things like uname -p or shortened long options behave differently.

I’d test with the gnu prefixed command, for example gnuuname -p, to confirm the cause, then fix the script to use portable options. Switching the whole server back to GNU coreutils is possible, but I’d rather fix the script.

4. How do you find the licence of a package that’s installed on a server?

Why they ask this: This tests practical package knowledge on both families, which comes up in audits and when vendors ask what you ship.

How you might answer: On RHEL or Rocky I run rpm -qi <package> and read the License field, which is in SPDX form, and the full text is under /usr/share/licenses/<package>.

On Ubuntu I read /usr/share/doc/<package>/copyright, which lists a License line for each group of files, and the common texts are in /usr/share/common-licenses.

Senior level

5. Your company wants to ship an appliance built on Linux to customers. What licence questions would you raise?

Why they ask this: Senior admins often build images that leave the building. They want to hear about distribution duties, source offers and keeping records.

How you might answer: Shipping the appliance is distribution, so the GPL duties apply: the kernel is GPLv2 and tools like bash and coreutils are GPLv3. We must be able to give customers the matching source code, including any changes we made, and GPLv3 adds rules about letting users install modified versions on consumer devices.

I’d keep a package list with licences for every image build, from rpm -qa or dpkg -l, avoid modifying GPL code unless we’re ready to publish it, and get legal to sign off before the first shipment.

6. Why did the GNU Hurd never replace Linux, and does that history matter to you as an admin?

Why they ask this: They’re checking depth and judgement: can you explain a design trade-off and connect it to real decisions.

How you might answer: The Hurd chose a Mach microkernel, waited years for Mach’s licence, and found the message-passing design very hard to debug. Linux was a simpler monolithic kernel that worked with the GNU tools in 1991, so developers moved to it.

It matters because the same trade-off shows up in every technology choice: the cleaner design isn’t always the one that ships. When I pick tools for a team, working and supported today usually beats elegant and unfinished.

Quick quiz

Q1. When did Richard Stallman announce the GNU Project?

  1. January 1984
  2. September 1983
  3. October 1985
  4. August 1991
Show answer

B — He posted the announcement on 27 September 1983. Work started in January 1984 and the FSF was founded in October 1985.

Q2. Which of these is NOT a GNU project?

  1. bash
  2. gcc
  3. glibc
  4. the Linux kernel
Show answer

D — The Linux kernel was written by Linus Torvalds. GNU’s own kernel is the Hurd.

Q3. What does copyleft require?

  1. You may never charge money for the software
  2. If you distribute the program or a changed version, you must pass on the source under the same terms
  3. You must publish every change you make, even for internal use
  4. You must credit the FSF on your website
Show answer

B — The duty starts when you distribute. Selling copies is allowed, and internal use creates no duty.

Q4. On Ubuntu 26.04, ls --version prints “uutils coreutils”. What does that mean?

  1. The server is broken
  2. ls comes from a Rust rewrite of coreutils, not GNU
  3. Ubuntu removed GNU coreutils completely
  4. It is a BusyBox build
Show answer

B — Ubuntu 26.04 uses rust-coreutils (uutils) by default and keeps the GNU versions installed with a gnu prefix, such as gnuls.

Q5. Where does Rocky Linux keep the licence file for the bash package?

  1. /etc/licenses/bash
  2. /usr/share/doc/bash/copyright
  3. /usr/share/licenses/bash/COPYING
  4. /var/lib/rpm/bash.license
Show answer

C — RPM installs licence files under /usr/share/licenses/<package>. The copyright file in /usr/share/doc is the Debian and Ubuntu way.

Quick recap

  • Richard Stallman announced GNU on 27 September 1983 to build a complete free Unix-like system. The FSF followed in 1985.
  • Free software means four freedoms (run, study, change, share), and copyleft (the GPL) keeps them attached when you distribute.
  • GNU gave Linux its compiler (gcc), C library (glibc), shell (bash) and everyday commands (coreutils). The GNU kernel, the Hurd, never became production ready.
  • Ask any tool who made it with --version, and find its package and licence with rpm -qf / rpm -qi or dpkg -S / /usr/share/doc/<package>/copyright.
  • Ubuntu 26.04 uses uutils for most core commands (GNU stays available as gnuls, gnucp and so on), so test scripts on the system they will run on.

Next lesson

Lesson 6: Linus Torvalds and the Linux kernel → You’ll see how a student’s hobby kernel from 1991 filled the gap GNU left, how kernel versions work today, and which kernels rocky01 and ubu01 run.

Further reading: GNU project

Want to go deeper into GNU project? Read Stallman’s initial GNU announcement, the free software definition, the quick guide to GPLv3 and Ubuntu’s 26.04 release notes, which explain the switch to rust-coreutils. You can also see the full plan for this course on the Linux Administration course page.

Scroll to Top

This website uses cookies

We use a few cookies to keep this site working. If you allow it, we also use Google Analytics to count visits so we can improve our lessons. You can accept all, deny the optional ones, or choose what to allow.