Y Dmitry Yarygin Tech
← Back to home

May 29, 2026

The Death of macOS: The NeXTSTEP Betrayal

How macOS moved from the open, inspectable NeXTSTEP inheritance toward a sealed Apple Silicon appliance.

I have been a Mac user for more than fifteen years.

For most of that time, I believed I was using one of the last genuinely personal operating systems: a UNIX workstation wrapped in elegant industrial design. It felt like something built for people who wanted to understand their machines, not just rent carefully managed experiences from them.

Today, that belief is much harder to maintain.

What we call macOS is the descendant of NeXTSTEP, one of the most technically coherent operating systems ever shipped to consumers. But the path from that engineering monument to the Apple Silicon era now looks less like a simple evolution and more like a slow domestication experiment.

To understand the scale of the change, we need to start not with Apple, but with NeXT.

Because the roots of modern macOS absolutely come from the NeXT era.

What NeXT Gave to macOS

NeXTSTEP was not just an old operating system with historical importance. Many of the core ideas that still define macOS came directly from it.

1. The Application Model

The entire macOS idea of an application as a self-contained .app bundle comes from NeXTSTEP.

An app is not merely a single executable file. It is a directory with structure, metadata, resources, localized assets, and supporting files. That model is still one of the most elegant parts of macOS. You can drag an app around like a file, but underneath it remains a structured software package.

That idea did not begin with modern macOS. It came from NeXT.

2. Objective-C

NeXT did not invent Objective-C, but it turned Objective-C into the foundation of an entire operating system.

Dynamic messaging, late binding, categories, protocols, runtime introspection — all of these became central to the NeXT development model. Modern macOS and iOS apps, even many written in Swift, still sit on top of the Objective-C runtime and frameworks that came out of that world.

Swift may be the modern language Apple promotes, but the bones are still Objective-C.

3. MVC as a Real Application Pattern

NeXT made Model-View-Controller more than a design pattern from a textbook.

It was built into the culture and infrastructure of the system. AppKit classes were divided around models, views, and controllers. Interface Builder encouraged that separation. Cocoa Bindings later extended the same philosophy.

Many platforms talked about MVC. NeXT made it feel native.

4. Cocoa and AppKit

AppKit and Foundation, the core of what later became Cocoa, were born in NeXTSTEP.

Classes such as NSObject, NSString, NSArray, NSWindow, and NSView still define macOS development today. Even the NS prefix is a living fossil. It means NeXTSTEP.

This is why macOS always felt different from other desktop operating systems. Its application framework was not an afterthought. It was part of the operating system’s identity.

5. Interface Builder

Interface Builder was radical for its time.

You could design interfaces visually, connect outlets and actions, and store them as serialized objects. Modern storyboards and SwiftUI previews are distant descendants of that original idea.

The important part is that Interface Builder was not just a mockup tool. It produced real application objects. That was a very NeXT-like idea: visual, elegant, and deeply technical at the same time.

6. Mach + BSD

The kernel lineage of today’s XNU began with NeXTSTEP’s combination of Mach and BSD.

Mach provided low-level primitives such as tasks, ports, memory management, and message passing. BSD provided the familiar UNIX environment. This hybrid architecture became the foundation of Mac OS X and, later, modern macOS.

7. A Composited Graphics Model

NeXT’s Display PostScript created the idea of a resolution-independent, fully composited desktop.

Quartz and Core Graphics followed the same conceptual path. Again, modern macOS did not appear from nowhere. It inherited a serious workstation-class graphics philosophy.

8. A Developer Culture

Project Builder, Interface Builder, Objective-C, AppKit, and Foundation formed a tightly integrated developer environment.

That culture eventually became Xcode and the Apple developer workflow. Before Apple made it glossy, NeXT made it coherent.

NeXTSTEP: The Architecture Apple Inherited

NeXTSTEP was not simply “another UNIX.” Its design was unusually clean.

At a high level, it combined:

This separation mattered.

Mach handled low-level system primitives. BSD delivered familiar UNIX semantics. Above both lived frameworks that treated the GUI as part of the operating system, not as a shell bolted on top.

Interface Builder generated real objects, not just mockups.

When Apple bought NeXT in 1997, this stack became Rhapsody and later Mac OS X. The kernel evolved into XNU, a hybrid of Mach and BSD with I/O Kit written in a restricted subset of C++.

Early OS X kept much of the NeXT attitude. The system was understandable. You could inspect it. You could learn it. You could modify large parts of it.

You could look inside:

Nothing felt completely sealed away.

The owner was root in the real sense.

How the Kernel Philosophy Shifted

On PowerPC and early Intel Macs, XNU behaved much more like a conventional UNIX kernel from the user’s point of view.

You could load kernel extensions. You could edit boot arguments. You could work with NVRAM. You could modify the root filesystem. You could treat the machine like a real workstation.

Developers debugged drivers with tools like kextload and kextunload. Audio interfaces, VPN clients, virtualization tools, filesystems, and hardware utilities all depended on this openness.

Then the direction changed.

The major turning points were:

Each step reduced the role of the owner and expanded the role of firmware, policy, signing, and Apple-controlled trust chains.

Today, XNU on Apple Silicon is only one component in a much larger chain:

Boot ROM → iBoot → LLB → kernelcache → macOS

Every stage verifies the next. The idea of casually booting a modified kernel on your own machine is effectively gone.

This is the core philosophical shift. The old Mac was a computer you could control.

The new Mac is a computer you are allowed to use.

Boot Camp: The Forgotten Symbol of Openness

For years, the Mac had an escape hatch: Boot Camp.

Introduced in 2006, Boot Camp was more than a convenience tool. It meant Apple was still willing to expose the Mac as a real computer.

It meant:

A Mac could be:

Many developers bought Macs precisely because one laptop could replace several machines. I remember running Windows XP on my iMac without needing to buy another computer for that. It was even fine for some gaming.

This ended with Apple Silicon.

There is no Boot Camp. There is no standard UEFI path. There is no official alternative OS support in the old sense. Virtualization remains, but the era of real dual boot is over.

Yes, Asahi Linux exists. It is an impressive project, and the people working on it deserve real respect. But after using it for a few weeks, I cannot say that I enjoyed the experience enough to call it a replacement for what we had before.

It is not the same as installing Windows or Linux on an Intel Mac and treating the machine like general-purpose hardware.

The Container Labyrinth

Classic OS X assumed a shared filesystem.

Modern macOS assumes isolation.

Apps now live behind containers, permissions, entitlements, privacy prompts, sandbox rules, and invisible policy layers. Preferences, caches, and documents are scattered across directories that are technically accessible but increasingly hostile to normal human understanding.

You can find yourself digging through paths like:

~/Library/Containers/
~/Library/Group Containers/
~/Library/Application Support/
~/Library/Preferences/

Sandboxing blocks or complicates things that used to feel normal:

Security improved. That part is real.

But everything has a price.

And the price is that I can no longer modify the system the way I want.

The irony is that Apple’s own apps and services often bypass many of these limits through private entitlements. Third-party developers and power users live inside the maze. Apple owns the map.

Investigating Performance Decay

On Intel Macs, the final years of support revealed another pattern.

Modern macOS increasingly seems designed around Apple Silicon assumptions:

That is understandable from Apple’s point of view. Apple sells Apple Silicon Macs now.

But for Intel Mac users, the result often feels like performance decay disguised as progress.

People upgrading older machines to newer macOS versions have reported issues such as:

Some of these problems are machine-specific. Some are fixable. Some are exaggerated by nostalgia.

But the pattern is hard to ignore: modern macOS feels less and less like an OS designed to scale gracefully across older hardware.

It feels like a platform optimized around Apple’s current hardware business.

Disk Utility: From Instrument to Toy

Old Disk Utility felt like a real system tool.

In the Snow Leopard era, it offered functionality such as:

Current Disk Utility is much simpler. It is cleaner, but also much less useful for serious work. Most real operations have moved to diskutil in Terminal.

This is a small example of a larger trend.

The graphical tools became friendlier, but also shallower. The serious system is still there, but increasingly hidden behind command-line tools, undocumented behavior, or Apple-only workflows.

The result is strange: macOS still contains powerful UNIX machinery, but the user-facing interface acts like you should not touch it.

What Was Lost

The modern Mac gained many things:

But it also lost a lot:

Apple will argue that this is the cost of security.

I do not fully reject that argument.

But I also do not accept the idea that every limitation is automatically justified because it arrives wearing a security badge.

At some point, security becomes governance.

Kernel Reality: XNU Then and Now

In the classic era, roughly from Mac OS X 10.4 through OS X 10.10, kernel extensions were first-class citizens.

They loaded through I/O Kit matching dictionaries. Userland could communicate with drivers through IOConnect and MIG. The prelinked kernel could be rebuilt. AMFI existed, but it was not yet the total policy layer it later became.

Developers could debug the living system.

Normal workflows included:

Modern macOS is different.

Kernel extensions have largely been replaced by DriverKit running in user space. The kernelcache is signed and tied into the sealed system volume. TrustCache and AMFI verify binaries at launch. Entitlements decide what kinds of IPC and system access an app may have.

Even recovery environments are mediated by policy.

The kernel is no longer a layer you interact with.

It is a monument you walk around.

Boot Camp and the Culture of Dual Boot

Boot Camp was more than a wizard.

It exposed how close Intel Macs were to ordinary PCs.

Technically, it relied on things like:

Power users built complex setups around this:

The T2 chip introduced the first serious cracks: secure boot levels, external boot restrictions, and DFU restore paths.

Apple Silicon ended the old story.

No UEFI. No Boot Camp. No alternative kernels in the old user-controlled sense. Only virtualization inside Apple’s rules.

A Mac stopped being a universal computer and became a single-platform appliance.

APFS and the Sealed World

APFS changed more than performance.

It changed the relationship between the user, the system, and storage.

With APFS, we got:

Some of this is technically impressive. Some of it is useful. Some of it makes recovery and updates safer.

But the consequences are real:

What looked like a filesystem upgrade also became a governance mechanism.

Conclusion: From Workstation to Appliance

macOS did not collapse.

It was gradually redefined.

NeXTSTEP assumed curiosity.

Early Mac OS X assumed competence. Modern macOS assumes compliance.

That is the real transformation.

The machine no longer fully belongs to the person in front of it. It belongs to the supply chain behind it: firmware, signing keys, entitlements, sealed volumes, policy engines, cloud services, and Apple-controlled restore paths.

I am not saying modern macOS is useless. It is polished, fast on Apple Silicon, secure by default, and excellent for many ordinary users.

But something important was lost. The old Mac felt like a beautiful UNIX workstation that happened to be friendly.

The modern Mac increasingly feels like an appliance that happens to expose a UNIX shell.

And I highly doubt Steve Jobs would have approved of that direction.