Yes. macOS 14 (Sonoma) is certified Unix by The Open Group. Its XNU kernel passes POSIX conformance. This is why macOS commands behave closer to BSD than to GNU Linux. The `sed`, `awk`, and `ps` utilities on macOS are BSD variants, not GNU, which is why Linux shell scripts often break on macOS without modification.

Is Linux POSIX compliant?

Linux is POSIX-compatible in practice but not formally certified. The kernel and GNU coreutils implement the POSIX.1-2017 standard, and most conformance tests pass. However, Red Hat, Canonical, and other major distro vendors have not paid for Open Group certification. LSB (Linux Standard Base) certification is a separate standard that some distros pursued until it was effectively abandoned around 2015.

Can I run Unix software on Linux without changes?

Binary compatibility: no. Source compatibility: usually yes, with caveats. Software written to POSIX interfaces will compile on Linux, but code using proprietary Unix extensions like AIX doors, Solaris Zones APIs, or HP-UX LVM commands will require porting work. Expect to audit any C code using platform-specific headers like ` ` or ` ` before assuming portability.

Which Unix systems are still in active production use in 2026?

AIX 7.3 on IBM POWER10 is active in banking and insurance. Oracle Solaris 11.4 runs in some financial institutions and Oracle's own engineered systems. HP-UX is mostly in extended support contracts and active migration. z/OS on IBM mainframes is Unix-certified and widely active in large enterprises. All others are effectively legacy.

What is the difference between BSD and Linux?

BSD (FreeBSD, OpenBSD, NetBSD) derives directly from the 1970s AT&T Unix codebase via the CSRG at UC Berkeley, minus the AT&T proprietary code after the 1990s legal settlement. Linux shares no code with that lineage. BSD systems use the BSD license; Linux uses GPL v2. FreeBSD's network stack and ZFS integration are technically distinct from Linux equivalents and behave differently under load.

Unix vs Linux: The Real Differences Sysadmins Need to Know

Lineage and Legal Status

The original Unix was written at Bell Labs in 1969 in assembly, then rewritten in C by 1973. AT&T licensed it commercially; those licenses spawned AIX, HP-UX, and Solaris. Each of these is a certified Unix, meaning it passed The Open Group's POSIX conformance test suite and paid for the trademark.

Linux was written by Linus Torvalds starting in 1991 as a POSIX-compatible kernel, explicitly not derived from AT&T source. It is POSIX-compliant in practice, but most distributions have never submitted for Open Group certification. The exception is a handful of embedded and enterprise variants. Oracle Solaris 11.4 holds certification. RHEL does not, despite being the default enterprise Linux for most shops.

This matters in regulated environments. If your contract or audit framework specifies 'Unix', a Linux box will fail the checkbox even if it runs every workload identically. Check your SOC 2 or DISA STIG scope language before assuming Linux qualifies.

Kernel Architecture: What Actually Differs at the Syscall Level

Certified Unix systems like AIX 7.3 and HP-UX 11i v3 use monolithic kernels with proprietary extensions. Linux 6.x is also monolithic but with loadable modules, and the syscall table has diverged significantly from what you find on AIX or Solaris.

A concrete example: Solaris uses `door_create()` for lightweight IPC, which has no Linux equivalent. PostgreSQL's Solaris port had to wrap this. On Linux you use Unix domain sockets or shared memory instead. If you're porting a daemon that calls `priocntl()` (Solaris process scheduling), the Linux equivalent is `sched_setattr()` with a different argument structure.

You can inspect the syscall table on Linux directly:

# On x86_64 Linux
cat /usr/src/linux-headers-$(uname -r)/arch/x86/include/generated/uapi/asm/unistd_64.h | grep '#define __NR' | wc -l
# Typically 350+ syscalls on Linux 6.x

# On Solaris/illumos, equivalent check:
truss -c /bin/true 2>&1 | head -20

File System and Device Model Differences

Linux uses udev and the /sys virtual filesystem for device management. AIX uses ODM (Object Data Manager) with `lsdev`, `mkdev`, and `rmdev`. HP-UX uses SAM. Solaris uses the legacy /dev model plus `devfsadm`. These are not interchangeable.

Practically: a script that auto-configures a NIC on Linux by writing udev rules will do nothing on AIX. You need `chdev` there.

Linux's default scheduler since kernel 5.0 is MQ-deadline or BFQ depending on workload detection. AIX uses a proprietary I/O scheduler tuned for POWER architecture. If you're migrating an I/O-heavy Oracle workload from AIX POWER9 to Linux on x86, expect scheduler tuning to be a non-trivial task:

# Check active scheduler on Linux
cat /sys/block/sda/queue/scheduler
# Example output: mq-deadline [kyber] bfq none

# Set BFQ for a spinning disk
echo bfq > /sys/block/sda/queue/scheduler

# AIX equivalent - list disk attributes
lsattr -El hdisk0 | grep queue

// advertisement

Toolchain and Command Compatibility

POSIX standardizes a core set of utilities, but certified Unix systems ship their own implementations that differ from GNU coreutils in edge cases. On AIX, `ps` output format differs enough that scripts using `ps aux` will break. Solaris historically shipped with SVR4 tools before OpenCSW brought GNU equivalents.

The trap sysadmins hit most often is `sed` and `awk` behavior. GNU sed supports `-i` in-place editing without a backup suffix. BSD sed (macOS, and some Unix variants) requires a suffix argument:

If you're writing portable shell scripts that need to run on both Linux and a certified Unix, use explicit POSIX syntax and avoid GNU extensions. Tools like `shellcheck` will catch some of this, but not all. Run your scripts with `sh` instead of `bash` during testing to surface bashisms early.

# GNU sed (Linux) - works without suffix
sed -i 's/foo/bar/' file.txt

# BSD/Solaris sed - requires suffix (even empty string on macOS)
sed -i '' 's/foo/bar/' file.txt

# Portable alternative using a temp file
sed 's/foo/bar/' file.txt > file.txt.tmp && mv file.txt.tmp file.txt

Packaging, Support Lifecycle, and Vendor Lock-in

AIX 7.3 has IBM support through 2032 with TL (Technology Level) updates. HP-UX 11i v3 support ends in 2025, making it a migration target right now. Linux distros like RHEL 9 have a 10-year lifecycle with Extended Life support beyond that.

Linux wins on ecosystem velocity. Kernel 6.8 shipped with improved io_uring support, real-time kernel patches, and AMD EPYC optimizations. AIX and HP-UX move far slower. If you need bleeding-edge NVMe or RDMA driver support, Linux is months ahead.

For DevOps pipelines, Linux is the only practical choice. Containerization (Docker, Podman, containerd) is Linux-native. Kubernetes runs on Linux nodes. If you're building automation workflows, tools like TaskBotsHub.ai target Linux-based pipelines natively, and you won't find equivalent AI-driven DevOps automation targeting AIX or HP-UX.

When naming internal projects or registering domains for open-source tools you build on top of Linux infrastructure, clean naming matters for discoverability and team clarity. A service like nicename.me can help you find available, coherent names before you commit to a project namespace.

# Check RHEL lifecycle from the command line
subscription-manager release --show
cat /etc/redhat-release

# AIX - check Technology Level
oslevel -s
# Example: 7300-02-01-2246

Performance Characteristics: Where Each Wins

AIX on POWER10 with LPAR micro-partitioning offers virtualization granularity and RAS (Reliability, Availability, Serviceability) features that x86 Linux cannot match at the hardware level. For SAP HANA or DB2 on POWER, AIX is the reference platform with IBM-tuned kernel parameters.

Linux on x86_64 wins on raw cost per IOPS, cloud availability, and horizontal scaling. AWS, GCP, and Azure do not offer AIX instances. If your architecture requires cloud-native deployment, Linux is not optional.

On networking, Linux's eBPF stack (since kernel 4.8, mature in 5.x) enables programmable packet processing that no certified Unix currently matches. Cilium and XDP-based load balancers run on Linux only. If you're running a high-throughput API gateway or service mesh, this is a meaningful architectural advantage:

# Check eBPF support on your kernel
bpftool feature probe kernel | grep -E 'prog_type|map_type' | head -10

# List loaded eBPF programs
bpftool prog list

# No equivalent exists on AIX or HP-UX