Linux vs Unix
Linux vs Unix is a line drawn over a naming dispute: Linux is not Unix, it is a free re-implementation of the parts of Unix that POSIX made public, while Unix remains a trademarked family of operating systems owned and licensed by The Open Group.
In 1996, 3 years after the lawsuit began, the Open Group settled with Novell, and that settlement lets any POSIX.1-certified system use the name Linux-branded Unix, a detail that explains why the comparison keeps resurfacing. The practical answer is that the kernel is free and the name is owned, and every comparison between the two systems hangs on that split. This page draws the line with the POSIX history and the naming rights, and then follows the question into the Unix culture that surrounds both systems, so the comparison stays tied to what actually differs in operation.
Is Linux Unix based, and where the line sits
Is Linux Unix based? No, not in any legal or code sense: the Linux kernel was written from scratch to the published specifications, and the line between the two systems is a legal boundary, not a technical one. The story runs in 3 steps. First, Unix appeared at Bell Labs in 1969, and its code and documentation spread by hand across universities through the 1970s and 1980s. Second, Sun Microsystems sued BSDi, a company built on that copied code, in 1992, and the case settled in 1993 with a licence that tied commercial Unix derivatives back to AT&T, which had acquired the code from Bell Labs in 1996. Third, in 1991 Linus Torvalds released the first Linux kernel version 0.01, built only from the published interface, and The Open Group settled with Novell in 1996, after which any POSIX.1-certified system can lawfully be called Unix. Linux is the result of that third path: it sits on the far side of the line, legally free but name-free, and the phrase Unix based applies to systems on the near side, such as BSD, AIX and HP-UX, whose ancestry runs through the original code.
POSIX: the part of Unix that anyone can build
POSIX is the reason Linux and Unix can be compared at all, because it is the shared contract: a family of specifications that freezes the interface both sides implement. POSIX was published by the Open Group in 1990, and the widely cited baseline is POSIX.1-2017, which defines the core API, the C library surface, the command shell behaviour and the utilities such as ls, grep and tar that every shell script depends on. The specifications cover roughly 1,500 documented calls and interfaces, a figure that is large enough to pin down the whole user-facing layer and small enough to re-implement independently. Linux implements that layer through the kernel system calls and the GNU userland, and the BSD and commercial systems implement it through their own stacks. Because the contract is public and royalty-free, the compatibility layer is a matter of conformance tests, not licences, which is exactly why a fresh kernel written 20 years apart from the original can pass the same certification and still not be Unix in the naming sense.
The naming rights: who can call a system Unix
The naming rights are where the line physically sits: Unix is a trademark, and The Open Group, the successor body that holds it, controls who may use the word. The mechanism is certification. A vendor submits its system to the Single UNIX Specification, now in version 4, and passes a conformance suite; if it passes, it may label the system Unix, as Solaris, AIX and HP-UX do in their certified editions. Linux fails the test for one reason only: it is not certified, because The Open Group does not certify it as Unix, and the Linux Foundation, which coordinates development of the Linux kernel, has never sought that label. The consequence is that the two most-used server operating systems on Earth carry the same interface and different names, and that the question of whether Linux is Unix based is answered differently by a lawyer, who says no, and by a sysadmin, who says the distinction is cosmetic. The rights were the subject of the 1992 and 1996 litigation, and they still gate the name today, which is the single fact that keeps the comparison alive.
Linus and Linux: the path that skipped the code
Linus and Linux shows how a system gets built without touching the original. Torvalds posted the kernel announcement to comp.os.minix in 1991 with a 40-page driver, version 0.01, and he built against the published interface documents rather than any Bell Labs source, because the litigation of that era made copying the code commercially radioactive. The first stable release, 1.0, shipped in 1994, and the project reached 3.0 in 2011 with a 1,000th milestone of its version counter. Each release is a public archive on kernel.org, and every commit is reviewable, so the provenance of the Linux kernel is a matter of public record: no copied files, only a re-implementation of the contract. That is the operational meaning of the line. A BSD system can be traced to the original code through a licence; a Linux system is traced to the specifications through a test suite. The two paths produce nearly identical shells, and the difference between them is the history, which is exactly what Unix culture preserves.
Where the fork shows up day to day
The fork is mostly invisible, and where it shows up is in the userland pairing rather than the kernel. The table below compares the two sides on the attributes that matter to a practitioner, using the same values everywhere they appear: the 1990 publication date for POSIX.1, the 1996 settlement, and the version 4 specification that The Open Group maintains.
| Attribute | Unix side | Linux side |
|---|---|---|
| Name rights | Trademark held by The Open Group, usable after certification | Kernel named by its author, no certification sought |
| Code provenance | Descended from the 1969 Bell Labs original, licensed after the 1996 settlement | Written from the published interface, first released in 1991 |
| Specification | Single UNIX Specification, version 4, certified per edition | POSIX.1-2017 conformance, verified by test suites |
| Userland | Vendor-supplied tools, such as the AIX base or the Solaris userland | GNU coreutils plus vendor packaging, as in Debian or RHEL |
| Examples | BSD, AIX, HP-UX, Solaris | Debian, RHEL, Ubuntu, openSUSE |
The pairing matters because the shell, the package manager and the init system come from the userland, not the kernel, which is why two Linux distributions can feel more different from each other than either is from a certified Unix. The line, in daily operation, is a label on the box, not a behaviour in the terminal.
Ubuntu vs Linux: a distribution is neither side
Ubuntu vs Linux is a useful contrast for the same reason, because a distribution is not a side of the line at all: it is a package of the kernel plus a userland, and Ubuntu ships the Linux kernel with a Debian-derived userland. Canonical released Ubuntu in 2004 with a 6 month release cycle, and it moved to an LTS cadence of 2 releases per year after 2010, with long-term support windows of 5 years for the standard edition. None of that changes the naming status: Ubuntu is a Linux distribution, it is not Unix, and it cannot be certified as Unix without changing what it ships. The contrast also fixes the vocabulary that the comparison uses: Unix names the family, Linux names the kernel, and a name like Ubuntu names the assembly. When a search for linux vs unix turns up distribution guides, the confusion is between those two levels, and the line between them is the same naming line drawn above. That is why the Unix culture section of this site treats distributions as the layer that carries the culture, not as a third answer to the original question.
What the line means for operations
What the line means for operations is that the comparison stops being about identity and becomes about portability, and portability is measured in the same 3 places: the shell scripts, the system calls and the package formats. POSIX.1-2017 keeps the first two portable across both sides, so a script written for a certified Unix runs on a Linux host without change in the large. The package formats, however, diverge completely: AIX uses the installp filesets, Solaris uses the pkgng and IPS packages, and Linux distributions use rpm and dpkg, so a porting effort is a packaging effort, not a kernel effort. The version counters track the divergence on each side, with the kernel at 6.x releases since the 2022 era and the Single UNIX Specification at version 4, and the gap between the two numbers is the size of the line. The practical rule is to write to the specification and test on the distribution, which is what the naming rights were designed to force: the name is a certificate of conformance, and the culture built around it is a discipline of conformance first, flavour second.