The Linux Command Timeline

The following is a Timeline of Linux Commands. Of course, before Linux even existed, there was Unix. This article will offer you a timeline of commands, from the early 70s into the mid 2020s. For a comprehensive history of Unix, GNU and Linux commands see: The history and evolution of Unix, GNU and Linux commands.

1970s: The Unix Era

1971 (Unix Version 1)

• cat, cp, rm, mv, ls, chmod, chown, mkdir, etc.
  These foundational commands appeared in the First Edition of the Unix Programmer’s Manual. They reflect the philosophy of small, single-purpose tools.

Early 1970s (Unix Versions 2–4)

• ed (line editor), sh (original shell), find, and other utility refinements.
  Unix’s core userland was expanding, though many commands were still very minimal compared to later GNU versions.

1973–1974

• sed (Stream EDitor) – Evolved as an advanced text-processing tool for non-interactive editing of streams of text.
• grep (Global Regular Expression Print) – Allegedly created by Ken Thompson around 1973–1974. It quickly became the go-to tool for searching text using patterns.
• file (this one doesn’t need an explanation) – Implemented with the major System V update of 1973, it allowed to search for files and directories across the entire or multiple filesystems.

Mid-to-Late 1970s

• awk (1977) – Created by Alfred Aho, Peter Weinberger, and Brian Kernighan. awk introduced a more expressive language for pattern scanning and processing, particularly useful in data extraction and reporting.
• vi (1976–1979 range) – Bill Joy’s visual editor appeared in Berkeley Unix (BSD). Became the de facto standard Unix text editor.

1980s: The Rise of GNU and BSD

1983

• GNU Project launched by Richard Stallman.
  Although not a single command, the GNU Project aimed to replace proprietary Unix software with free software, sparking the creation of GNU coreutils (free implementations of ls, cp, mv, and more).

Mid-1980s

• less (1985) – Introduced by Mark Nudelman as an improved pager over more. “Less is more, but more or less.”
• Expansion of BSD Unix brought enhancements to existing commands (including ps, ifconfig, and the C shell csh).

1989

• bash (Bourne Again SHell) – The GNU replacement for the original Bourne shell, sh. Quickly became the default interactive shell on many Linux distributions.

Early 1990s: Linux Emerges

1991

• Linux kernel (Linus Torvalds). While not a userland “command,” the kernel’s release catalyzed an ecosystem that adopted the existing GNU userland tools as its foundation.

1992–1993

• Slackware (1993), Debian (1993), Red Hat (1994)
  Early distros assembled the Linux kernel with GNU tools, standardizing the environment and package management. Commands like dpkg, rpm, etc., evolved in these distributions.

Mid-to-Late 1990s: Consolidation & Specialization

1996

• BusyBox – Created for embedded systems, consolidates numerous standard commands into a single small-footprint binary.

1998 (approx.)

• ip (iproute2 suite) – A more modern replacement for ifconfig, route, and netstat, offering more advanced networking configuration options.

2000s: Modernizing the Toolchain

• Continued refinement of GNU coreutils with extra flags (e.g., ls --color, grep -P).
• Gawk (GNU Awk) gained new features beyond the original AWK.
• Package managers matured:
  • Debian/Ubuntu-based: apt-get → apt
  • Red Hat-based: yum → dnf
  • Others: pacman (Arch), zypper (openSUSE).

2010s: New Paradigms (systemd, Containers, etc.)

2010

• systemd – Replaced SysV init scripts, introducing commands like systemctl and journalctl for managing services and logs.

2013

• Docker – Containerizing applications became the new norm, making commands like docker run, docker build, and docker exec essential for many developers and sysadmins.

Mid-to-Late 2010s

• Podman, Buildah, and other container tools emerged as more open, “daemonless” alternatives to Docker.
• Kubernetes/kubectl soared in popularity for container orchestration.

2020s and Beyond

• Containers, virtualization, and orchestration tools continue to evolve, but they build on classic Unix design principles and often rely on (or wrap) the same core commands (ls, grep, cat, etc.).
• Security is more prominent, with commands like firejail, SELinux (semanage), and AppArmor (aa-* commands) seeing greater usage.
• Automation with tools like Ansible or Terraform harnesses the power of these classic commands under the hood, orchestrating them at scale.

You can continue reading about the evolution of Unix, GNU and Linux commands in the following article: The history and evolution of Unix, GNU and Linux commands.