
Illumos is a Unix operating system which provides next-generation features - doener
https://www.illumos.org/
======
mapgrep
I really hope users and developers can embrace the amazing technology that is
present in illumos and its derivatives, much of which came out of Sun Solaris.

Things like ZFS, Zones, DTrace, SMF, and Crossbow were locked up inside Sun
Solaris for many years because it was proprietary. The effort to open source
it took a long time and because of how Solaris was built (with various third
party things) Sun essentially had to release under a slightly odd license, the
CDDL.

Meanwhile Linux, which had ascended to dominance post dot com bubble,
solidified its lead as the defacto default server operating system, a fairly
well earned dominance built on being the first truly free Unix available for
x86/PC hardware, and at a time when that was a truly lesser tier of hardware
(unlike today).

But today I worry we've settled into a mindset of "the linux way is best
because it is dominant" \- if you use linux you can google your stack traces,
you know that even if the tech is inferior ( _cough_ btrfs _cough_ systemtap
_cough_ systemd _cough_ epoll*cough) many other people are in the same boat
and in theory hordes of developers will -- might? -- make patches to fix the
problem. No one ever got fired for choosing linux, basically.

I've migrated a bunch of personal projects to a server I own running SmartOS,
an Illumos derivative. One thing I've learned is that it's actually really
viable and nice these days to use an alternative operating system. I imagine
it's similar with FreeBSD, OpenBSD, vanilla Illumos, etc. These systems run on
a pretty impressive array of hardware and are able to leverage the near total
standardization of the hardware/bios stack and the inroads made by other
projects to bootstrap to viability. E.g. SmartOS uses pkgsrc from the netbsd
project for packaging, took some boot technology from FreeBSD, and in general
is able to tap into the universe of "unix like" tools, even if many of those
tools are most often used on linux.

Anyway if you get a chance give this stuff a spin, it's pretty eye opening
what you can accomplish. Zones, to me in particular, feel like a game changer.

~~~
romaniitedomum
> you know that even if the tech is inferior
> (coughbtrfscoughsystemtapcoughsystemdcoughepoll*cough) many other people are
> in the same boat and in theory hordes of developers will -- might? -- make
> patches to fix the problem.

Bit of a bad cough you have there! Need a lozenge?

With regard to technology, Solaris/Illumos went through the same init system
battle with their next-gen init system SMF as GNU/Linux did with systemd. They
had their share of hard-nosed refuseniks who vowed to remain on Solaris 9
forever rather than embrace the new. Lennart Poettering said that systemd was
inspired in part by SMF[1].

[1] [https://coreos.com/blog/qa-with-lennart-
systemd.html](https://coreos.com/blog/qa-with-lennart-systemd.html)

~~~
jsiepkes
Sure SMF wasn't universally liked with its introduction. Just like Apples
Launchd. However the big difference is that for those 2 the resistance was
mostly attributable to people not liking change. And that kind of resistance
fades over time. Since its basically still the same thing only somewhat
different.

However the problem most people have with systemd is the massive (growing)
scope. So because it keeps growing and changing the "resistance" people have
towards it gets refueled all the time.

------
phendrenad2
Illumos is a fork of OpenSolaris that's under active development, and the last
Unix based on AT&T Unix System V. It's features have been around forever, and
have been ported to Linux and BSD (with various levels of success). So "next-
gen" is a strange way to describe it...

~~~
TallGuyShort
HP-UX 11 is also based on System V [1], and that had a release as recently as
6 months ago [2].

[1]
[https://en.wikipedia.org/wiki/Unix#/media/File:Unix_history-...](https://en.wikipedia.org/wiki/Unix#/media/File:Unix_history-
simple.svg) [2] [https://en.wikipedia.org/wiki/HP-
UX](https://en.wikipedia.org/wiki/HP-UX)

~~~
tilt_error
I wonder what letter hides behind the ‘-‘?

Probably the worst ever OS to develop against. I worked for almost 10 years
with a product codebase that was maintained on Solaris (really nice), Linux
(nice), AIX (not so nice) and HP-UX (not at all nice).

~~~
paol
The longstanding joke is to substitute 'S' for the '-'.

Around 2000 I briefly worked at a telco equipment manufacturer that shipped
for Solaris, AIX and HP-UX. Back then the hierarchy was already as you
described.

~~~
hvs
That was true in the mid-90's as well, although I remember hating AIX and HP-
UX about equally.

------
cies
Why not state that it is a fork of OpenSolaris on the homepage? Also the "next
gen FS" is just ZFS, first released in 2005 (and they say software moves
fast).

I think the homepage is mostly tageting techies, why not put a little more
jargon in there and be transparent about the origins?

~~~
jclulow
It's been a tough needle to thread. Most everybody who has positive feelings
about Solaris history already knows where we come from, and it's mentioned in
the history section of our documentation site.

For others, prominently featuring our Solaris heritage doesn't always result
in a good first impression. It's pretty easy to hear Solaris and think "old"
and "unmaintained" and so on, for whatever reason. We're trying instead to
have people judge the software we ship first, rather than prejudge based on
our history.

The other perception we try to combat is that we're compatible with binaries
for Solaris 11 -- after a decade of divergent development on both sides, we're
just not.

~~~
cies
> Most everybody who has positive feelings about Solaris history already knows
> where we come fro

I was in doubt. There is an OS release every week now, I think being based on
a mature one only gives me more hope.

Maybe also say something about what you want to achieve (a serious alternative
for Linux on the server), or name some companies that use it currently in
production.

> It's pretty easy to hear Solaris and think "old" and "unmaintained"

This is better countered by a list of recent releases and/or recent commits.

> The other perception we try to combat is that we're compatible with binaries
> for Solaris 11 -- after a decade of divergent development on both sides,
> we're just not.

This is not for the front page, but good to mention at some point.

------
nerdponx
I'm a "casual" user - I do various hobbyist activities (Python and machine
learning projects, 3d modeling, photo editing, et al) as well as basic stuff
like email and browsing Hacker News. I don't intend to do much "low-level
hacking" or application development.

Is Illumos interesting for someone like me? Or should I stick with GNU/Linux?

~~~
porker
Stick with whatever you know and are comfortable with.

------
npx
Competition from Linux has become very stiff. For me, Kubuntu 19.10 delivers
on all of the promises that OpenSolaris made back in the day. My laptop has
two 1TB SSDs in a ZFS mirror. Docker works as you'd hope, creating a new ZFS
dataset for each container. I have remarkably good hardware support,
everything just works. I'd say that the user experience rivals or beats MacOS
or Windows, although at this point I'd say it is largely just a matter of
preference.

Linux still lacks the multitenant security guarantees of Solaris Zones but
this isn't so bad. Hard multitenancy is a problem that only concerns a fairly
small subset of people and even then, there are solutions. You can do hard
multitenancy with Linux containers (namespaces/cgroups to be pedantic) if you
start restricting the system call table. There is also Firecracker[1] which
obviously isn't as efficient as Zones (because it uses VMs), but is proven in
production and does provide additional security guarantees.

The technical advantages of Illumos are outweighed (or rivaled) at this point,
in my opinion. When I show people things on my laptop, I always end up talking
about the desktop cube in KDE or my neovim/tmux/zsh setup. Due to ZFS
snapshots and the power of zfs send/recv, I expect this system installation to
last for years to come. No more reinstalls, we're good, this operating system
thing is covered.

1: [https://github.com/firecracker-microvm/firecracker-
container...](https://github.com/firecracker-microvm/firecracker-containerd)

~~~
npx
To get off into the weeds a bit... I've actually spent quite a bit of time
using Illumos. The epicenter of The Suck begins, in my mind, with the effort
involved in actually building the system.

GCC (and Clang) obviously didn't exist back in the day, so none of the
Makefiles for the base system are written for a compiler that was released in
the past 20 years. There is actually a wrapper that takes SunCC arguments and
calls GCC... so that kinda works, right?

Okay, well, yes. It works. But then, it all kinda starts snowballing. There is
a big investment in a debugger from the 1980s which can't unwind stacks
without frame pointers. So... we have to emit frame pointers. Okay, that
works. Because we care a lot about this, we'll also ensure that all function
arguments promoted to registers are also copied to the stack so we can always
look at them. Okay, fair enough.

Is this idiosyncratic enough for you yet? Okay, let's step it up a few notches
and actually implement the Linux system call table on top of this. Wait, what?
The struggle is real.

This is all technically brilliant in any number of ways, but I have things to
do this week. All of the man years of effort spent on Linux and the
surrounding ecosystem have actually solved a lot of real technical problems
and solved them incredibly well.

~~~
jclulow
Like any large scale project with a long history, we certainly have our share
of eccentricities. We're working on moving the argument translation from cw
(our "compiler wrapper") more directly into the Makefiles themselves.

I would note that both Studio and GCC are both older than 20 years if you're
going by the date when they were first released; releases of both that we were
using (Studio is no longer in use) were released more recently than 20 years
ago. We currently recommend people use GCC 7.3 or 7.4 to build the OS, and
those were released in the last two years.

The debugger I believe you're talking about is MDB[1], which is emphatically
not from the 1980s. It was started as a project in the lead up to Solaris 7,
as I understand, which was closer to 2000. GDB was first released in 1986, but
I don't think either of these dates are a meaningful observation: they're both
actively maintained debuggers with a different approach and a different focus.

There are lots of arguments for, and presumably against, the use of %rsp as a
frame pointer. They're all trade-offs. The amd64 architecture is, at least,
less register starved than 32-bit x86. Stack unwinding with correct use of the
frame pointer is substantially less complex than using the unwinding
information provided by DWARF sections. This helps a lot when making the
stack() and ustack() DTrace routines available, as they need to unwind the
stack in an extremely limited context in the kernel. Saving arguments to the
stack (-msave-args) is another trade-off tilting the scale toward a better
debugging experience, because yes, we do care a lot about that as a project.

At the end of the day, you should use whatever makes you happy and solves
problems for you. Those of us who work on illumos, use it at home, or ship it
in products, are doing so for just that reason.

[1]:
[https://en.wikipedia.org/wiki/Modular_Debugger](https://en.wikipedia.org/wiki/Modular_Debugger)

------
thinkingkong
Illumos has some incredible technology packed into it but lots of those have
been ported, re-implemented, or turned into billion dollar companies. The
extra special parts like being able to debug v8 in mdb have this strange
alignment issue: How many node developers are going to fire up an alternative
operating system and learn a new debugger to be able to find a memory leak?

~~~
gnode
> How many node developers are going to fire up an alternative operating
> system and learn a new debugger to be able to find a memory leak?

I don't think this is much of a barrier, especially when "fire up" means: run
a VM instance. Using various VMs and/or containers for development is already
a common workflow.

I think the unfamiliarity of Illumos for most developers would be more of a
barrier.

------
miker64
Is there something new that's happened for this to be news?

~~~
ryancnelson
there's an OpenZFS summit going on this week, so I imagine that's why this and
OmniOS became top-of-mind for some: [http://www.open-
zfs.org/wiki/OpenZFS_Developer_Summit_2019](http://www.open-
zfs.org/wiki/OpenZFS_Developer_Summit_2019)

~~~
miker64
Thanks for the context!

