History: from SunOS to Solnix

Solnix did not appear from nowhere. It is the newest link in a chain that runs back more than forty years, through some of the most influential operating- system engineering ever done. Knowing the lineage makes the rest of this handbook click into place — why the commands look the way they do, why ZFS and DTrace and zones all live in one coherent system, and what Solnix is (and isn’t).

The thread that connects all of it is a single idea that keeps recurring in this story: that systems software is most valuable when it is shared — read, criticized, improved, and carried forward by more hands than any one company can hire. That idea is older than Sun, older than BSD; it runs back to the research labs where Unix was born and to a university that decided the right thing to do with great code was to give it away. Solnix is a late inheritor of that conviction, and this chapter traces how the conviction (and the code) travelled from AT&T’s Unix room to a laptop running solnix-rebuild today.

SunOS — the BSD years, and the AT&T / Berkeley roots (1970s–1980s)

To start with SunOS is to start one generation too late. The real root is AT&T Unix, written at Bell Labs beginning in 1969 by Ken Thompson and Dennis Ritchie (with Rudd Canaday, Brian Kernighan, Doug McIlroy, and Joe Ossanna shaping its tools and philosophy). Unix was small, composable, and — crucially for everything that followed — written mostly in C, so it could move between machines. Because a 1956 antitrust consent decree barred AT&T from selling software, Bell Labs licensed Unix, source included, to universities for a nominal fee. That accident of regulation is why Unix spread through academia instead of staying a Bell Labs secret.

That early culture of shared source did not last on its own — it had to be fought for, and the fight produced the ideas and licenses that Solnix depends on today. In 1983 Richard Stallman announced the GNU Project (“GNU’s Not Unix”) to build a complete, free Unix-compatible system after watching proprietary licensing lock away code that had once been shared; in 1985 he founded the Free Software Foundation (FSF) and later wrote the GNU General Public License (GPL), whose copyleft — you may use and modify, but derivatives must stay free — became the legal engine of the free-software movement. GNU’s tools (GCC, Emacs, bash, coreutils, and the rest) are the userland most Unix-like systems, Linux included, were built from, and they are the GNU/BSD tools a Solnix user still finds on PATH. When Linus Torvalds released the Linux kernel in 1991 under the GPL, it was GNU’s userland and GNU’s license that made it a usable, legally durable system — the “GNU/Linux” pairing Stallman asks us to name in full. Solnix sits on the other branch of that same story (the illumos kernel rather than Linux), but it inherits the movement’s central premise: that the source should travel with the software. The licensing arguments that shaped OpenSolaris’s CDDL two decades later (below) are a direct continuation of the debate Stallman started here.

The university that did the most with it was the University of California, Berkeley. Starting in the mid-1970s, Berkeley’s Computer Systems Research Group (CSRG) turned its AT&T license into the Berkeley Software Distribution (BSD) — at first add-on tools, then a near-complete reworking of the system. Bill Joy, then a Berkeley graduate student, was the central figure: he wrote the vi editor and the C shell (csh), assembled the early BSD releases, and — most consequentially — led the integration of TCP/IP networking and the sockets API into 4.1c/4.2BSD under a DARPA contract, giving Unix the network stack that would carry the Internet. Marshall Kirk McKusick designed the Berkeley Fast File System (FFS) and later shepherded CSRG and the BSD lineage for decades; Sam Leffler, Keith Bostic, Mike Karels, and Özalp Babaoğlu (author of early Unix virtual-memory work) were among the others whose names recur in the BSD changelogs. Berkeley also pushed Unix toward virtual memory, reliable signals, and the long demand-paged-VM tradition that Sun’s engineers would later rebuild.

In 1982 Bill Joy left Berkeley to co-found Sun Microsystems, and he brought the BSD sensibility with him. Sun’s first workstations ran SunOS, a Unix built directly on 4.xBSD: bsd-style tooling, the Fast File System, sockets and TCP/IP, vi and csh — tuned for Sun’s Motorola- and later SPARC-based hardware, and extended by Sun with NFS (the Network File System, which Sun published as an open protocol) and the first serious workstation virtual-memory and VFS architecture. Through the 1980s SunOS was a BSD system in all but name, and it set the house style — networked, graphical, developer-friendly — that Solaris, illumos, and Solnix still carry. This is the true root of the family tree: Solnix is, at bottom, a descendant of AT&T Unix as reimagined at Berkeley and commercialized at Sun.

SunOS 5 / Solaris — the SVR4 rewrite (1992)

In 1992 Sun made a decisive break — and it was a wrenching one, because it meant setting aside the pure-BSD system its own users loved. Sun partnered with AT&T itself to co-develop System V Release 4 (SVR4), explicitly intended as the unification of the industry’s two great Unix branches: AT&T’s commercial System V and Berkeley’s BSD. SVR4 folded in the best of both — BSD’s sockets, FFS (as UFS), job control, and csh; System V’s STREAMS, the Service Access Facility, shared memory and the SysV IPC suite, and the /usr and packaging conventions — into one standard. Sun shipped its implementation as SunOS 5, marketed as Solaris 2. (This is the source of the enduring confusion: “SunOS” became the kernel/version string uname reports — SunOS 5.x — while “Solaris” was the product brand. illumos still answers SunOS to uname today, and so does Solnix.)

The migration was painful and famous: longtime SunOS 4 (BSD) users had to relearn packaging, init, and device naming, and Sun maintained a BSD-compatibility layer for years to ease the transition. But the SVR4 bet is why the modern system looks the way it does. This heritage is why illumos — and therefore Solnix — uses SVR4 conventions: the /usr layout, the SVR4 packaging model that later evolved into IPS, the STREAMS-derived networking and device frameworks, the service and driver interfaces, and much of the userland shape a Linux admin finds slightly unfamiliar. Solaris was, from 1992 on, a System V system with deep Berkeley blood — exactly the hybrid Solnix inherits.

The Solaris innovations (late 1990s–2000s)

Over the next fifteen years Solaris stopped merely unifying other people’s ideas and became a laboratory that generated its own — a run of operating-system research, shipped in a production OS, that the rest of the industry spent the following decade imitating. Sun’s willingness to fund deep kernel work (and to hire and keep the engineers who could do it) made Solaris the place where several now-ubiquitous ideas were first made real at scale. The ones Solnix inherits directly:

ZFS — a pooled-storage filesystem and volume manager with end-to-end checksums, copy-on-write transactions, cheap snapshots, clones, and built-in RAID. It erased the decades-old split between “filesystem” and “volume manager” and made silent data corruption detectable. See ZFS storage.
DTrace — safe, production-grade dynamic tracing of the whole system, kernel and userland, from one scripting language, with zero overhead when not enabled. It changed how a generation of engineers debugs live systems. See DTrace.
SMF — the Service Management Facility: a dependency-aware init system and service supervisor with a fault boundary, automatic restart, and a queryable repository — years before Linux’s init debate settled on anything comparable. See SMF services.
Zones — OS-level virtualization (lightweight, near-zero-overhead containers with their own process table, network, and filesystem view) years before Linux containers existed. See Zones.
Crossbow — network virtualization in the kernel: virtual NICs, virtual switches, flows, and bandwidth controls, so a single host could carve up its networking the way Zones carved up the OS. See Networking (Crossbow).
FMA — the Fault Management Architecture: hardware and software errors diagnosed into faults with stable message IDs, so a failing DIMM or disk produces an actionable, documented event instead of a cryptic panic. See illumos features.

Any one of these would have been a notable system in its own right; most research groups would build a career on a single one. Solaris shipped all of them, integrated and supported, in one coherent OS — which is exactly the platform Solnix builds on, and exactly why a project this small can offer capabilities this large: we did not have to invent them, only to package them.

Stewardship: packaging and release discipline at Sun’s peak

The technology was only half of what made Solaris formidable; the other half was stewardship — the unglamorous discipline of versioning, packaging, and predictable releases, done well for over a decade. Solaris’s pkg/SVR4 packaging (and later the network-based IPS, the Image Packaging System built for OpenSolaris) was genuinely ahead of its time: packages with real dependency metadata, cryptographic verification, a system-wide notion of a coherent, versioned “this is a supported configuration,” and — with ZFS — the ability to snapshot the whole system before an update and roll back cleanly if it went wrong. (If that sounds familiar, it should: it is the same instinct Solnix now serves with Nix generations and ZFS boot environments.) Around it Sun ran a model of release stewardship that enterprises could set their watches by — a clear Solaris 2.x → 7 → 8 → 9 → 10 cadence, long support lifecycles, binary compatibility guarantees so strict that applications built for an early Solaris release would still run years later, and a single, accountable owner answering for the whole stack.

That single-owner model is the “one throat to choke” that enterprise buyers prize: one vendor to certify the hardware, ship the patches, honor the support contract, and take the blame. It is a real strength — as long as that owner is healthy, competent, and interested in leading. Sun, at its peak, was all three, and Solaris was arguably the best-stewarded commercial Unix in the industry. But the model has a single point of failure that is not technical at all: the owner’s will. When Sun faltered and was acquired, the same concentration that had made Solaris dependable became the thing that could switch it off — which is exactly what the next sections describe.

OpenSolaris — the open-sourcing (2005)

In 2005 Sun did something almost no commercial Unix vendor had been willing to do: it released the source of a shipping, flagship, revenue-bearing operating system. Under the newly-written CDDL (Common Development and Distribution License), the OpenSolaris project put the kernel, ZFS, DTrace, SMF, Zones, FMA, and most of the core userland into public, buildable source. For the first time anyone could read how production ZFS actually worked, build the kernel from source, send fixes, and ship a derivative. It was a genuine inflection point — the moment the technology stopped being Sun’s alone and became the commons that Solnix now draws from.

The release was also a deliberate community-building act, not just a code drop. Sun stood up mailing lists and discussion forums, opened its bug database, published the build tools and the “OS/Net” (ON) consolidation gate, created the OpenSolaris Governing Board, and actively courted outside developers and downstream distributions. Within a couple of years a real ecosystem had formed: multiple distributions, a port to other hardware, and a steady inflow of external contributors. The CDDL (file-level copyleft, deliberately not GPL-compatible) was itself a considered choice — it let Solaris code be shared openly while remaining practical for a company with patents and a commercial product to protect. That same license is why illumos is open today, and why the whole lineage below 2005 is auditable source rather than legend.

Sun was choosing a license at a moment when open licensing had matured well beyond the original GPL. The Creative Commons had been founded in 2001 by Lawrence Lessig, Hal Abelson, and Eric Eldred (growing out of Lessig’s free-culture work and his Eldred v. Ashcroft copyright challenge), and by 2005 its share-with-conditions model had made the very idea of a spectrum of public licenses mainstream — not just for software but for writing, images, and data. (This handbook and the Solnix docs are themselves offered in that spirit.) The CDDL was Sun’s own point on that spectrum: based on Mozilla’s MPL, file-scoped, patent-aware. The broader lesson of the era — that “open” is a set of carefully chosen terms, not a single switch — is one Solnix takes seriously in how it signs, licenses, and attributes everything it ships.

The world OpenSolaris was born into — and where it was headed

To understand why OpenSolaris mattered, place it in 2005. Linux (kernel 2.6) was ascendant and improving fast, but it was still catching up on serious storage and observability: there was no production answer to ZFS (btrfs would not begin until 2007 and stayed experimental for years), no DTrace (SystemTap was young and fragile, and strace/gdb were no substitute for whole-system tracing), and kernel-native containers were years away (LXC landed around 2008, Docker in 2013, both clearly in the lineage of ideas Zones had already shipped). The BSDs were healthy and genuinely open — FreeBSD 5/6, NetBSD, OpenBSD, and the young DragonFly BSD — technically respected and in some areas ahead, but without ZFS or DTrace at the time; tellingly, FreeBSD would soon import both directly from OpenSolaris. Proprietary Unix was in visible retreat: SGI’s IRIX, DEC/HP’s Tru64, and HP-UX were winding down, IBM’s AIX was holding on in enterprise shops, and the broader “Unix wars” had largely burned out. Apple’s Mac OS X had just begun its Intel transition on a Mach/BSD foundation. Microsoft’s Windows Server 2003 owned the corporate datacenter by unit count.

Against that backdrop OpenSolaris was genuinely unique: the only open-source system that shipped ZFS, DTrace, SMF, Zones, Crossbow, and FMA together, in one integrated, production-grade, enterprise-supported OS. Nothing else, open or closed, combined that specific set.

Its intended future was correspondingly ambitious. Sun positioned OpenSolaris as the open foundation of a thriving, Linux-style ecosystem. The flagship effort was Project Indiana, led by Ian Murdock — the founder of Debian, hired by Sun exactly for his distribution-building credibility — which shipped as OpenSolaris 2008.05: a friendly, single-CD, live-installable desktop-and-server distribution with a modern, network-based package manager (IPS, the Image Packaging System) and a GNOME desktop, deliberately approachable to Linux users. The plan was for the open codebase and the commercial Solaris to advance together, with the outside community as a first-class participant rather than an afterthought — Sun even shipped the commercial Solaris 10 and 11 express builds from the same open gate. ZFS and DTrace were already spreading to other operating systems, and OpenSolaris was meant to be the hub of that diffusion: the reference implementation everyone else learned from. That trajectory was cut short in 2010 — but, as the rest of this chapter shows, the fork preserved both the technology and a surprising amount of the original intent.

The family tree since open source

Everything below the 2005 open-sourcing is one tree. The last open OpenSolaris drop became the illumos gate, and every living illumos system — including Solnix — descends from it. Oracle Solaris is the one closed branch off to the side.

Green = open; red = closed (Oracle Solaris); gold = Solnix. Every open branch shares the 2010 illumos gate as its upstream.

Text version of the same tree (for screen readers / plain text):

SunOS (BSD, early 1980s)
  └─ Solaris / SunOS 5 (SVR4, 1992)
       └─ OpenSolaris (CDDL, open-sourced 2005)
            ├─ Oracle Solaris 11+ ............ CLOSED again (2010)
            └─ illumos gate ................. community fork of the last
                 │                             open drop (2010), still open
                 ├─ OpenIndiana   (desktop/server; the direct successor)
                 ├─ OmniOS        (minimal, stable server)
                 ├─ SmartOS       (hypervisor; zones + LX-branded zones)
                 ├─ Tribblix      (retro, lightweight package manager)
                 └─ solnix        (Nix / NixOS module system on illumos)  ← this OS

Oracle closes Solaris (2010)

Oracle completed its acquisition of Sun Microsystems in early 2010, and the change in posture was swift. In August 2010 an internal memo leaked that laid out the new direction plainly: Solaris development would continue, but behind closed doors, with source released only after a binary shipped (if at all), under a restrictive license. The OpenSolaris Governing Board, seeing it had no partner left to govern with, dissolved itself. The regular open source drops simply stopped; the public onnv gate went quiet. Oracle shipped Solaris 11 in 2011 as a wholly proprietary product.

For the community that had spent five years building on the open code, this was an existential moment. Thousands of person-years of engineering — ZFS, DTrace, Zones, the whole integrated system — had been public and buildable, and overnight the upstream was gone. Many of the key Sun engineers also left in the wake of the acquisition, scattering to companies that would soon become central to the open story (notably Joyent, Nexenta, and Delphix). The question was no longer “how do we contribute upstream?” but “is there an upstream at all?” The answer had to be built from the last open bytes Sun had released.

The community forks: illumos (2010)

Rather than let the open codebase die, the community forked the last open OpenSolaris drop into a new project: illumos, announced by Garrett D’Amore (then at Nexenta) in August 2010 and quickly joined by many of the ex-Sun engineers. The name nods to illumination (and keeps the “-os” of the heritage), and to the ON (“OS/Net”) consolidation it descends from — the core kernel-plus-network userland gate that had always been the heart of Solaris.

The fork was not a simple copy. A handful of components in the OpenSolaris tree had never actually been open-sourced — Sun had shipped them as closed binaries inside the otherwise-open system (parts of the C library’s crypto, some drivers, assorted utilities). To make a fully free gate that could build without any Oracle-owned bits, the illumos project had to replace those closed pieces with new open implementations — painstaking, unglamorous work that was the difference between “mostly open” and “actually buildable by anyone.” The result became what this handbook calls the illumos gate: a fully open, community-maintained continuation of the OpenSolaris kernel and core userland, with no proprietary dependencies, that has been developed continuously ever since. See How Solnix is built.

Two things are worth stating plainly, because they are a common source of confusion. First, illumos is not Solaris and is not owned by Oracle — it is the open, living branch that forked before Oracle closed the gates; Oracle’s Solaris 11+ is the separate, closed branch. Second, the fork preserved not just code but continuity: the same engineers, conventions, uname string, and engineering culture carried straight across, so illumos is better understood as OpenSolaris-continued than as a from-scratch reimplementation. Solnix sits at the far end of that unbroken line.

With thanks — the people who made Solaris open

Solnix exists because, twenty years ago, a group of people fought to put this technology in the open and then kept it alive when its original owner walked away. Credit in a project like this is not a formality — it is the honest accounting of a debt. We wrote almost none of what makes this system remarkable; we are standing on the shoulders of the people named below (and many we have missed). It is right to name them.

Making OpenSolaris happen (2004–2005). Opening a shipping, commercial Unix was not inevitable — it took engineers, lawyers, program managers, and executives inside Sun who believed the code belonged to the community, and who were willing to do the slow, political, unglamorous work of actually getting it released. Among many:

Jonathan Schwartz and Scott McNealy — the Sun executives (CEO and chairman/CEO) who publicly committed Sun to open-sourcing Solaris and defended the decision internally when it would have been easier not to.
Danese Cooper, Sun’s “open-source diva” and a central figure in Sun’s open-source strategy, and the legal/licensing team who navigated the minefield of releasing patent-encumbered enterprise code — producing the CDDL so the source could ship cleanly and defensibly.
Claire Giordano, who helped lead and shape the OpenSolaris community effort — the programs, the launch, and the connective tissue between Sun and the outside developers — the kind of community-and-communications work that determines whether an “open” project is open in practice or only on paper.
Stephen Hahn and Bart Smaalders, who designed and built IPS (the Image Packaging System) for the OpenSolaris distribution — the modern, network-based package manager Project Indiana needed.
The ZFS team — Jeff Bonwick and Matt Ahrens foremost (with Bill Moore and others) — whose filesystem became the single most influential thing OpenSolaris gave the world, and who argued for and supported its open release.
The DTrace authors — Bryan Cantrill, Mike Shapiro, and Adam Leventhal — who built safe production tracing, evangelized it relentlessly, and then helped carry the community forward after the acquisition.
Mike Shapiro again, and the engineers behind SMF and FMA; the Zones team led by Andrew Tucker (with the later resource-management and branded-zones work); and the broad OS/Net (ON) consolidation engineering organization whose collective work quite literally is the gate.
Ian Murdock — founder of Debian — who led Project Indiana, the effort to turn OpenSolaris into an approachable, Linux-friendly distribution. (Murdock died in 2015; the distribution model he pushed for lives on in every illumos distro, this one included.)

Sun engineers across the longer arc. Beyond the 2005 launch, Solaris and its open descendants carry the fingerprints of many more Sun (and ex-Sun) engineers, before and after the open-sourcing:

Bill Joy — Sun co-founder, and before that the Berkeley student who gave Unix vi, csh, and its TCP/IP networking (see the BSD section above); the single clearest human link between Berkeley Unix and Sun.
Andy Bechtolsheim and Vinod Khosla — Sun’s other co-founders, whose hardware and company made the software possible.
James Gosling — of Java fame, but a deep Sun systems figure whose presence shaped the engineering culture that produced this work.
Rich McDougall and Jim Mauro — whose Solaris Internals books documented the kernel so thoroughly that outsiders could actually learn it.
Casper Dik, Alan Hargreaves, and the many kernel and performance engineers whose names fill the SunSolve archives and the ON changelogs.
Dan Price, Jerry Jelinek, and the Zones/branded-zones engineers whose work later made LX-branded zones (Linux binaries on the illumos kernel) possible — see LX-branded zones.

Keeping it alive (2010 and after). When Oracle closed the gates, OpenSolaris would have become a dead archive without the people who forked it and then sustained it for over a decade:

Garrett D’Amore, who launched illumos, replaced the last closed-source components Oracle had never opened, and did the founding organizational work so a fully-free gate could exist, build, and attract contributors.
The companies that gave ex-Sun engineers a home and funded continued illumos work — Nexenta (ZFS storage), Joyent (cloud + SmartOS, under the renewed leadership of Bryan Cantrill), and Delphix (where Matt Ahrens continued core ZFS/OpenZFS work).
The distributions that carried the gate into production and still do: OpenIndiana, OmniOS (and the community OmniOSce after Oracle-era sponsorship changed), SmartOS (Joyent, now MNX), and Tribblix (Peter Tribble, a one-person labor of love).
The OpenZFS community, which reunited the ZFS forks across illumos, FreeBSD, Linux, and macOS into one shared codebase — arguably the clearest proof that the open release worked.
Everyone who, for fifteen years since, has kept the gate compiling, the drivers current, the man pages honest, and the knowledge documented. Solnix is downstream of all of it.

If you worked on any of this and we’ve under-credited you — or worse, missed you — that’s our error, not a slight. Tell us (see Contributing) and we’ll fix it. The honest summary bears repeating: we wrote almost none of what makes this system remarkable. We packaged it with Nix, and we are grateful to stand on it.

What OpenSolaris gave the world — its influence elsewhere

The truest measure of OpenSolaris is not the distributions that descend from its gate, but how much of it other systems took, mimicked, re-implemented, or were plainly inspired by. For a project whose commercial owner abandoned it, the diffusion is remarkable — several of its ideas are now simply how computing is done, often on systems whose users have never heard the name “Solaris.”

ZFS — adopted almost everywhere, mostly as literal code.

FreeBSD imported ZFS directly from OpenSolaris (2007) and made it a first-class, officially-supported filesystem — the CDDL source dropped straight in. For years FreeBSD was the most prominent production home of ZFS outside Solaris.
Linux gained ZFS via ZFS on Linux (an out-of-tree module, kept separate precisely because CDDL and GPL don’t mix) — widely used despite the licensing awkwardness, and the backbone of appliances like TrueNAS (formerly FreeNAS) and countless storage boxes.
macOS had an official Apple ZFS port in progress (later cancelled), kept alive by the community as OpenZFS on OS X.
All of these eventually converged into OpenZFS, a single shared codebase spanning illumos, FreeBSD, Linux, and macOS — the OpenSolaris filesystem, now the de-facto open standard for serious storage, maintained in common by the very ecosystems it spread to.
Even systems that did not adopt ZFS were pushed by it: btrfs on Linux and Microsoft’s ReFS are both clear responses to the pooled-storage, checksummed, copy-on-write model ZFS proved.

DTrace — reimplemented and chased for fifteen years.

FreeBSD and NetBSD ported DTrace directly from the OpenSolaris source.
macOS shipped DTrace (Apple built Instruments partly on top of it), as did (briefly) QNX and others.
Oracle ported DTrace to Oracle Linux — ironically re-opening the technology it had closed in Solaris.
On mainline Linux, DTrace’s influence is written all over the modern observability stack: SystemTap chased it first, and today eBPF — with tools like bpftrace whose language is deliberately DTrace-like — is in large part the Linux world finally building what DTrace demonstrated was possible. Engineers who learned tracing on DTrace built much of it.

Zones — the container idea, shipped first.

OpenSolaris Zones (2004) were production OS-level virtualization years before Linux had anything equivalent. The lineage of ideas runs through LXC (2008) to Docker (2013) and the entire container industry. The implementations are independent, but Zones demonstrated — at scale, in production — that lightweight per-application OS virtualization was the right model, and Joyent ran a public cloud on Zones for years to prove it.

SMF, FMA, and the rest.

SMF’s dependency-aware, self-healing, repository-backed service model prefigured much of what the Linux world argued about and eventually got with systemd — a convergent answer to the same problem SMF had already shipped.
FMA’s structured, message-ID’d fault diagnosis influenced how later systems think about turning raw errors into actionable, documented events.
Crossbow’s in-kernel network virtualization (VNICs, virtual switches, flows) anticipated the virtual-networking primitives that cloud and container networking now take for granted.

Taken together: a storage layer that became the open standard, a tracing model the whole industry rebuilt, and a virtualization idea that seeded an entire industry. OpenSolaris may have “lost” commercially, but as a set of ideas it won comprehensively — and Solnix gets to run the originals, integrated, rather than the imitations.

The illumos distribution ecosystem

Just as Linux is a single kernel that dozens of distributions package in their own way, illumos is one gate that several distributions build on — each taking the identical kernel-and-core-userland and differing mostly in packaging, defaults, release cadence, and intended use. Knowing the siblings helps place Solnix among them:

OpenIndiana — the most direct OpenSolaris successor and the general-purpose desktop/server distribution. It inherited Project Indiana’s IPS packaging and GNOME desktop and is the closest thing to “what OpenSolaris 2008.05 would have become.” If you want the traditional Solaris experience, open, this is it.
OmniOS (and the community-run OmniOSce) — a deliberately minimal, rock-stable server distribution with a conservative release model and long support windows. Built for people who want illumos as boring, dependable infrastructure — storage servers, hypervisors, appliances.
SmartOS (Joyent, now MNX) — a hypervisor-focused distribution that boots from RAM/USB and runs everything in zones. It pioneered the modern LX-branded zone — running unmodified Linux binaries on the illumos kernel via a Linux syscall-emulation layer (see LX-branded zones) — and powered a public cloud, proving illumos at serious scale.
Tribblix — a retro-flavored, intentionally lightweight distribution with its own minimal package manager (zap), largely the work of one person, Peter Tribble, and a reminder that an illumos distro can be small and personal.

Each takes the same gate and makes different trade-offs. Solnix is the newest sibling, and it makes the most unusual trade-off of all — described next.

Models of stewardship — and why Solnix chose a new one

Step back and the whole chapter is really a story about how software is governed, told through one codebase changing hands. It is worth naming the models explicitly, because Solnix is a deliberate choice among them.

The single-commercial-owner model (Sun’s Solaris) gives you coherence, accountability, and “one throat to choke” — and it works beautifully until the owner loses interest or capacity, at which point the same concentration becomes a kill switch. Oracle proved the downside in a single year.

Linux is the great natural experiment in the alternative, and its history is a survey of stewardship models tried, transformed, and sometimes abandoned. One kernel, many distributions, governed every which way: a benevolent-dictator kernel (Torvalds) over a foundation-funded commons (the Linux Foundation); a volunteer social contract (Debian, governed by its constitution and elected leader); a community edition feeding a commercial product (Fedora → RHEL; openSUSE → SLE); a purely commercial distribution that later had its community rug pulled (CentOS, redirected to Stream — a vivid repeat of the Solaris-under-Oracle lesson); and community forks born from exactly that betrayal (Rocky Linux, AlmaLinux). Some of these models thrived; some curdled the moment a commercial sponsor’s incentives shifted. The pattern is clear: governance, not technology, is what usually decides whether an operating system stays trustworthy over decades.

illumos chose the community-fork model out of necessity in 2010 — and kept the technology alive, which is no small thing. But honesty requires naming where that left it: OpenSolaris/illumos today is highly fragmented and lightly used. It is several small distributions sharing a gate, maintained heroically by a dedicated few, and it is no longer widely taken seriously as a choice for production servers or for the desktop. The engineering is still world-class; the adoption, reach, and momentum are not.

Solnix is a deliberate attempt to change that — by pairing the best technology in this story with a different model for everything around it. The bet is specific: take the genuinely remarkable OpenSolaris/illumos assets — ZFS, DTrace, SMF, Zones, Crossbow, FMA, the whole integrated kernel — and wrap them in the Nix model for building, distributing, and certifying software: reproducible packages, a signed binary cache, a trust model where what you install is provably what was reviewed, and atomic, rollback-able system generations. On top of that, a new community governance model (see Community build federation and Contributing): not one commercial throat to choke, and not an ad-hoc volunteer scramble either, but reproducibility-as-trust — many independent builders able to verify each other’s work, with a single transparent signing authority rather than a single corporate owner.

The Solnix team believes this is the best road forward for the assets in OpenSolaris/illumos: keep the irreplaceable kernel engineering, replace the fragile stewardship and dated packaging around it, modernize the rough edges, and — critically — bring device-driver support up to date, the single biggest thing standing between illumos and real desktop and server use today. The goal is unabashed: to make Solnix a genuinely good choice for a desktop or a server again, and to see adoption increase steadily as those rough edges are smoothed — for the benefit of everyone who ever depended on this lineage. The technology earned a second life; Solnix is an attempt to give it one.

And finally: Solnix

Solnix — the Solnix Operating System — is the newest illumos distribution, and it differs in one specific way: instead of a traditional package manager (IPS, or SmartOS’s pkgsrc), it uses Nix and the NixOS module system to build and manage the whole system declaratively. It is designed as a first-class OS across four CPU targets — x86_64, aarch64, RISC-V, and SPARC — for both server and desktop use, and optimized for virtualized hosting on the major cloud platforms. Each configuration change produces a new, atomically-activated system backed by a ZFS boot environment; rollback is instant.

To be precise about what Solnix is and isn’t:

Solnix is illumos — the same kernel, ZFS, DTrace, SMF, zones, Crossbow, and FMA described above — packaged and managed with Nix.
Solnix is not Linux. It does not use the Linux kernel, glibc, or systemd.
Solnix is not NixOS. It reuses NixOS’s evaluator and module system, but targets the illumos kernel and userland, not Linux.
Solnix is not Oracle Solaris. It descends from the open illumos branch, not Oracle’s closed product.

Status. Solnix is early — a first preview image just landed (see Introduction). The history above is real and settled; Solnix’s own place in it is just beginning.

The solnix handbook