Don't forget Symbian, probably the last successful operating system designed from scratch.

It started life as EPOC32, the operating system for "palmtop" devices made by UK-based Psion in the mid-90s; then Nokia and Ericsson decided they needed a smartphone OS that isn't Microsoft and bought into EPOC creating Symbian sometime around 1998. It took a while for Symbian to get off the ground because the hardware wasn't there yet and the partners kept bickering, but by 2006 it was shipping on a hundred million devices and was perceived as very successful against Microsoft's Windows Mobile. A few years later, Symbian would be trounced to oblivion by iOS and Android.

The interesting thing about Symbian was that it had a rich native framework but wasn't even close to POSIX or Windows. You didn't even get the C standard library; instead the system was built on an idiosyncratic embedded-centric dialect of '90s C++. This focus on optimization at expense of programmer convenience turned out to be a total dead-end once PC-style operating systems became viable on phones — but at least it made for a distinctive development experience.

And of course finally it went FOSS: https://github.com/SymbianSource

I'm surprised nobody has even attempted to pick it up, AFAICT. A very good OS in its day.

I miss WebOS

It's open-source on an OpenEmbedded base, shipping in LG TVs.

http://webosose.org/develop/architecture/

Webos is just linux with specific wm.

The story of GEOS is quote interesting too. From 8bit OS for c64 in mid 80ies to powering Nokia Communicator and a bunch of random Japanese products in mid/2nd half 90ies.

No, it's not on multiple fronts. Copland failed internally before it ever hit the market (i.e. it was never generally released.) Sure, the NeXT acquisition was the final nail in the coffin for it, but it had failed long before that. Part of the reason for the NeXT acquisition was that Copland was such a mess. It could be argued whether NeXT or Be was the better option, but Apple desperately needed to buy an OS... because Apple didn't have something that was going to ship.

>It could be argued whether NeXT or Be was the better option,

I think a lot of people start mashing years together when it comes to BeOS. Apple announced the NeXT acquisition in December 1996.

In December 1996, BeOS was still a developer preview with the first "real" release still about two years away. NeXTStep was already 8 years old.

In 1996 BeOS was at a completely different state of readiness and maturity than it was with R5 (which everyone remembers fondly).

USENET is full of posts, 96-98, of individual developers announcing with triumph the porting of UNIX core utilities to the BeOS developer release versions-- utilities that were already present and mature in NeXT/Openstep.

Mac OS X Server 1.0 was released about two years after the deal was finalized and I imagine it would have taken about two years of really hard work just to make BeOS multiuser, nevermind porting all of the core utilities.

It took a couple more years (it was a somewhat jerky transition for many users) before a "usable" OS X was released but from the beginning there was an wide variety of software available for it that was easily ported from NS/OS, and features like Display Postscript, Objective-C, a mature set of APIs, and most importantly of all Project Builder were there from the beginning.

The software scene on BeOS in 1996 was... sparse.

In 1996 Mac users were far more familiar with BeOS than NeXTSTEP. Even though it was a developer release, Be was marketing heavily to Mac users (like giving away free CDs) and BeOS could run on Macs so Mac users could try it side-by-side with MacOS and form firsthand impressions. (I was triple-booting MacOS, BeOS, and Linux on my Power Mac with a bunch of Jaz carts.) Meanwhile NeXTSTEP was expensive and ran on expensive non-Mac hardware.

BeOS was also optimized (probably over-optimized) for first impressions; the immaturity and architectural mistakes were hidden behind a facade of "OMG it's so fast and pretty". The BeOS GUI with its cartoony 32x32 icons was also a lot closer to MacOS than NeXTSTEP with it's huge high-DPI GUI, so BeOS looked like "Mac done right" while NeXT was a foreign culture.

So yeah, NeXT was better but most Mac users had no way of knowing that at the time.

Agree with everything you said and NeXT was the right call (even sans Jobs). Apple needed mature ecosystem, libraries, etc, not just a base OS.

However, BeOS was far more stable/mature than its 'developer release' status implied. I remember how blown away people were at the dev release in 1996 by how solid it was, not just by how forward thinking its features were.

I don't think multiuser would have been a showstopper for release if BeOS was acquired by Apple. They could have put out 2-3 versions of a single user OS and few would have cared.

something I have been wondering about for years, having been around: was Be actually acquisition bait from day one for Apple? I am convinced that NeXT wasn't; they just didn't build something that was designed for acquisition.

But Be, Inc. and BeOS really strike me as the kind of design, company, compromises, focus and leadership/team that I've come to associate with startups that are actually designed to be acquired by the executive's former employer after some time.

I would love to know if this is true, though in my experience, that is usually only known to the founders and executives except in the really obvious cases.

It was started by a former apple executive Jean-Louis Gassee [1]. At apple he said he wanted a kernel on macOS[2]. When he started BE they did develop their own hardware (BE Box). They eventually decided to port it other hardware (hardware is expensive). Microsoft had a strangle hold on most PC manufacturers and the BEbox was power PC so it made sense to try to get Mac clones to use it (There was a brief period in the 90s where apple clones existed.). I got a disk and tried it on a "Power computing" mac clone. It was kinda amazing compared to macos8. But the lack of software made it hard day to day.

[1]https://en.wikipedia.org/wiki/Jean-Louis_Gassée

[2] https://mondaynote.com/50-years-in-tech-part-11-getting-the-...

https://en.wikipedia.org/wiki/BeBox

I'm aware of all that history. The part I'm asking about is whether his exit plan was Apple and when that exit plan went with the other option the company was not viable.

This is very common for "startups" founded by executives who come from a company they know is failing to execute on something critical.

Be smells like this.

One wonders, what if someone else had bought Be?

Someone did: PalmSource (the software spinoff from Palm). It was to be the basis for their Palm OS “Cobalt”, which was eventually abandoned.

Or by “someone else”, did you mean someone other than PalmSource?

Let’s be honest, though: most new OSes don’t enjoy much success or longevity. The only successful new arrival I can remember recently was Android, and it had the backing of Google, and was aimed at a relatively new market. It also borrowed heavily from established tech: Linux kernel, JDK and JVM.

I doubt there’s more than a handful companies that could have turned BeOS into something big, and of those, Apple was probably their best bet.

Someone who actually had a chance to do something with BeOS, and of sticking around for longer than a few years.

Minor notes:

* BeOS was evaluated by Apple as a Copland replacement (along with Solaris, NT, and NeXTSTEP).

* MacOS X discarded DPS for Quartz so it didn't turn out to be much of a feature. But very few applications touched that directly so it wasn't much of a porting issue.

* There was more UNIX and AppKit-based software available for NeXTSTEP than for BeOS but nobody in the Mac world cared about that. Quark were the only company that really blew the transition, but they blew it badly.

Preceded by Apple's late-80s failure with the "Pink" OS:

http://lowendmac.com/2014/pink-apples-first-stab-at-a-modern...

It wasn't actually proceeded by Pink. Copland and Pink were going on in parallel, and the competition between them (and the original MacOS folks as well) was intense. Pink was the first to lose that battle, and got spun out as a result.

Source: I worked on Pink/Taligent for six years. Prior to that I supported A/UX and MPW in MacDTS.

The most amazing story of the 90s was the incredible ball of failure that was Taligent. It's almost impossible to even describe to people the situation around it and get them to understand how crazy the world went for a time. Taligent (and OO, to an extent) was the industry's equivalent to the satanic ritual abuse panic - it dominated the conversation for a brief time but was then solidly forgotten, no one really mentions it, and when you try to tell people born later they don't really believe you.

I agree that the OO hype at the time was crazy, and I was extremely guilty of that mania at the time. But from my POV (as a Pink/Taligent employee) the failures of Taligent had little to do with that. It was much more a problem of constantly moving goalposts (we're an OS! Now we're an OS and a layer on top of AIX! Now we're going to be an optional window manager for AIX!) and vicious politics.

I think that, if we're talking about Taligent itself, that's probably true. I've talked to other Taligenters and they say the last bit in particular.

But the books, the books were straight up crazy and people reacted to them in the same unfortunate way that they reacted to "Design Patterns."

Another of the crazy OS companies that deserves mention on the list of failures is both the Newton and Magic Cap.

Also, even though Taligent was a monumental disaster, it wasn't all bad. There is a lot of stuff you use every day that came directly out of Taligent's work. For instance, the i18n libraries for Java and ICU (http://site.icu-project.org/design/cpp) were early important work. A lot of unicode came from Taligent's work (but not all of it), and the President of the Unicode Consortium, Mark Davis, did a lot of the formative work at Taligent. So at the end of the day you can thank (or blame) Taligent for emojis.

Taligent also had quite a bit of influence on the field of unit testing, which I'm proud to have had a hand in. I've written about this in the past: https://shebanator.com/2007/08/21/a-brief-history-of-test-fr...

It is true that many good things come out of failures. There's a lot of value in trying and _not_ succeeding.

I'm a bit of a student of failure. If we want to really dive into deep failure, someone mentioned Workplace OS, which was not just a terrible project but a terrible idea (in the same way that NT's original concept of multiple-OS-personalities was wrt: OS/2 16 bit, for example, and POSIX, just taken to an entirely more crazy level).

For truly fun crazy, one has to step away from OS projects to things like graphics (for example, Fahrenheit and Talisman).

I wrote one of those books, specifically "The Power of Frameworks". Like I said, I was definitely deep in the hype cycle at the time.

https://www.amazon.com/Power-Frameworks-Windows-Os/dp/020148...

Taligent and OO frameworks in general had a massive impact of hype/unreality across the industry that spread to other other desktop or networked OO technologies, such as OpenDoc, CORBA, and WS-*. COM/DCOM/COM+ and OLE got caught in this and mostly succeeded in its niche but remained terrible complicated.

There was also IBM's SOM (System Object Model), used extensively in OS/2. SOM/DSOM was inspired by CORBA, just like COM. All of them uses an IDL and are based on querying for supported interfaces, which is a very powerful mechanism.

They all died except COM, which remains the basis for most APIs that Microsoft release these days (even after a brief stumble with .NET where they, if I remember correctly, they tried to kill COM). It's a great technology, and it's a shame that Microsoft didn't open it up and turn it into a truly cross-platform technology.

What didn't take over the world was this notion of object-oriented documents, which was what OpenDoc and Taligent were all about. This idea that content came with behaviour; you could embed an object from one app into another, e.g. a piece of an Excel table into a Word document, and the table would be live-updateable within Word, with all your interactions basically going between processes as COM calls, with the OO behaviour following the embedded content as it moved around, even when copy-pasted between documents. Very powerful, but super brittle. I used embedding a lot in the 1990s, trying to achieve what the PR told me should be feasible and easy, but it invariably ended with app crashes.

It turns out that hyperlinking / embedding shouldn’t involve you giving your memory address space to someone else - who knew :)

And really, the web/REST wound up being the object oriented document framework we were all looking for. It was terribly inefficient at first (and is still) but was architecturally simpler. The main issue is no one thought it would be possible to replace Windows with a cross platform GUI, and no one thought hypertext/hypermedia - a mostly academic concept at the time beyond HyperCard - would be that GUI.

https://www.slideshare.net/StuC/oopsla-2007-the-web-distribu...

Right — as I remember, if you embedded an Excel object into Word, the Excel part was implemented in a DLL that loaded directly into the Word process space. This would have been so much more stable if it instead started a headless Excel server process. With DCOM, this kind of cross-process COM worked great, but that came much later. OLE 1.0 preceded COM by several years.

They didn’t die. CFPlugin in Core Foundation that runs on every iPhone and Mac is an implementation of COM

"They all died except COM".

And I would argue they CFPlugin is only really inspired by COM, it's not the real thing. It's just IUnknown and the same class layout:

> The CFPlugIn model is compatible with the basics of Microsoft's COM architecture. What this means is that CFPlugIn Interfaces are laid out according to the COM guidelines and that all Interfaces must inherit from COM's IUnknown Interface. These are the only things that CFPlugIn shares with COM. Other COM concepts such as the IClassFactory Interface, aggregation, out-of-process servers, the Windows registry, etc... are not mapped.

http://mirror.informatimago.com/next/developer.apple.com/doc...

It isn't fair to blame Taligent for that hype. Several of these systems existed before Pink/Taligent project was ever discussed publicly. Heck, we used to talk about how our stuff was better than COM and CORBA all the time.

And OpenDoc was developed more or less simultaneously with Pink IIRC. But its been a long time and I never worked on OpenDoc so I might have the timing off a bit on this one.

That is a great metaphor for how important things like Taligent seemed at the time, which is hard to imagine now. Does anyone remember the Newton OS? It was very strange and still kind of visionary. There were all these bold ideas for operating systems and we kind of settled on Unix with a GUI layer or VAX with a GUI layer. That was good enough.

Add one onto the early-'90s failure list: IBM Workplace OS. Rarely mentioned these days for some reason, but a hugely hyped and super-expensive complete failure.

From the Wikipedia page https://en.wikipedia.org/wiki/Workplace_OS: A University of California case study described the Workplace OS project as "one of the most significant operating systems software investments of all time" and "one of the largest operating system failures in modern times".

Linux was started in 1991, so it really belongs in the BeOS era. But Linux isn't an apples-to-apples comparison. It's success followed the rise of the internet, and the resulting huge demand for a free server OS. No commercial vendors were providing that.

The other OS's you mentioned are all Desktop OS's, and that market was already buttoned up by the 90s, as it largely still is today. They were up against much steeper odds.

The OS part, the GNU userland, was written before the 90s. The kernel was just the missing piece that made it all work on a 386 desktop that were rising in popularity at the time.

It's interesting how the gnu project narrative of "we did all the work, the kernel was 'just the missing piece'" has propagated.

The gnu project worked on a kernel - Hurd. It has been "in active development" since 1990. It's "just the missing piece."

Hurd was a microkernel that was a genuine attempt at something new. Linux’s monolithic design was very safe, very 70’s/80’s, and was criticized by everyone for not being a serious 90’s microkernel design.

This was covered extensively over 25 years ago, including the classic comment by Linus that "In fact the /whole/ linux kernel is much smaller than the 386-dependent things in [the existing microkernel] mach". https://www.oreilly.com/openbook/opensources/book/appa.html

Mach and Hurd were existing microkernels/projects before Linux development began.

Linux dominated because it (partly) worked and was accessible and a community formed around it. Hurd had none of those. It's the canonical proof of Richard Gabriel's prescient "Worse is Better (1991)" http://dreamsongs.com/WIB.html - "The good news is that in 1995 we will have a good operating system and programming language; the bad news is that they will be Unix and C++."

NeXT mach was a microkernel as well based on CMU’s Mach 2.5 (in the first release) and was in the market in 1988. It was actually fantastic, even when I was running 0.7 of the OS in prerelease at LANL. Hurd started in 1990 so it wasn’t NEW new imho (originally based on Mach 3.0 although NeXT went there too). There are other ideological differences but the core mach microkernel ideology started at CMU in 1985 making microkernels an 80s technology as well.

I'm really stretching to remember, but I recall that initially the Hurd was planning to have a completely distributed user system (i.e., file handles were essentially URLs, they had a system for dealing with users distributed in the network, etc). They were going to use the Mach kernel message passing in really innovative ways and I seem to recall that they had in mind some fairly radical ideas for distributed processing. I don't think they ever really realized any of that (I haven't actually checked what they ended up doing). My impression was that the project was dogged with a lot of problems, some technical and some not. Had they succeeded, it would have been a really amazing system, I think. One of these days I keep thinking I should check out what they actually did.

Let's be fair to both sides here. The new way of working that Linus brought about absolutely crushed Hurd's "We have our team of experts and we don't want any help". It wasn't so much that the Hurd was destined to fail to deliver, it's more that the success of Linux made it completely irrelevant at a pace that nobody would have expected (not even Linus). I mean they even beat the law suits to free up BSD.

This is one of the few things my feeble ageing memory recalls fairly clearly :-) I desperately wanted to work on the Hurd, but they rejected me because I was a noob. Then I was desperately waiting for BSD to pass through the legal gauntlet. Then a colleague said, "What about Linux? They just got X working. It seems pretty good". It really came out of nowhere -- not necessarily due to good development (thought there was lots of that), but rather because key early contributors were encouraged and enabled to participate by Linus. We were all desperately waiting and many talented people just leaped at the opportunity to do something (not me, unfortunately -- I got sidetracked with work :-P).

In comparison to the rest of GNU, it was just a piece. A pretty big piece, but just a piece none-the-less. Keep in mind the amount of work that went into GCC and glibc, which at the time were comparable projects. Without those pieces, Linus would have nowhere to start. Then all the user land tools -- again, without those I don't think anybody would have joined in. They would have waited for BSD. And those user land tools were really good. The first thing I did when I installed a new Unix box was install GNU. GNU was important in Unix land before anyone had ever heard of Linux. Sometimes I think younger people have no real concept about how much code was part of GNU. The goal of GNU was to give you a fully functioning POSIX system. One of the reasons we even have POSIX is because of the work of the guys working on GNU.

When we say that it's Linux with GNU, that's really to distinguish it from, say, Linux with Android. Or Linux with BSD (if anyone does that). I'm not actually sure how much GNU is regularly used in a Linux distro these days, but I still prefer it to alternatives (maybe I'm just old). Again, we're really talking about having a full POSIX compliant system and the kernel is just a part of that. Linux is super fantastic and I actually choose Linux over other possible kernels because of how good it is. But I'm never going to run Android on my desktop, no matter that it runs a Linux kernel. I'd rather not run Android on my phone, if I had any choice in the matter!

To be even more fair, I always thought we should have given X a bit more air time. Especially these days, it's important to me if I've got X or Wayland running. But it was always a bit daft to think that people were going to be saying GNU/Linux. It's even more daft to think that people would say GNU/X/Linux or GNU/Wayland/Linux. It really doeasn't roll off the tongue ;-)

I think a big part of it was the community that formed around the Linux brand. I have a feeling that it could have been Minix, if it was properly open source at the time. But a lot of people in the community were promoting Linux as an alternative to Dos/Windows (based on my recollection of Usenet and BBS postings at the time), whereas GNU, BSD were pushed as an alternative to Unix. And Minix's aim was educational, although Minix 386 (a set of community patches to the system) was more aimed to make Minix production capable.

"I think a big part of it was the community that formed around the Linux brand. "

People are criticizing Linus for lack of social skills but somehow he managed to start a big and loyal community. That's not a small feat.

More to the point, Linux was going out of it's way to retread technology from the '70s. This is shown by the fact that it had ready-made userland in the form of GNU components that had been built to be Unix compatible.

Linux is the just the kernel for an 80's based OS.

Linux is a kernel though, not an operating system. I don’t care at all for the GNU/Linux debate but it is of course important not to take the start of one part as the start of the whole thing.

It was built on solid foundations however.

1993: FreeBSD

Fork of older upstream project which was a collection of mods for an even older upstream project. Not 90s.

I'd just like to interject for a moment...

If we're looking at kernels, there have clearly been substantially rewritten kernels that launched in the 90s; they succeeded by maintaining backwards compatibility with userland software written in the 70s/80s.

If we're looking at userland, the only successful general-purpose operating systems in the last 30 years that started from scratch with no apps at all are iOS and Android. (Even there, arguably their killer app was backwards compatibility with the desktop web.)

All others, including Windows, OS X, and Linux, had solid backwards compatibility facilities supporting software written for DOS, System 9, and Unix, respectively.

Tend to agree. All the OS attempts that tried to seriously innovate the desktop failed. Add WinFS and OpenDoc to that list.

And OS/2.

It's kind of sad that we are so stuck in the current paradigms. The 90s were definitely much more exciting in terms of innovation.

It's because the only innovations that "count" in the mainstream marketplace are the ones that take us from "not good enough" to "good enough", not those that take us from "good enough" to "excellent". In other words - as a startup, you get customers by taking a non-consumer and turning them into a consumer. It's very hard to take a consumer and turn them into a consumer of something else.

In the 70s we went from "not good enough" to "good enough" in price, but once we got to the PC clone wars of the mid-80s it was hard to go much lower. Then in the 80s and early 90s we went from "not good enough" to "good enough" in user experience, with MacOS 7 and Win 95. The 90s OSes were all attempting to take a "good enough" user experience and make it excellent, and that's where they failed - most mainstream consumers don't care enough about excellence to make it worth learning a new OS. Instead the late 90s and early 00s took us from "not good enough" to "good enough" in information, with a big cost in user experience. The web sucked as a UI and still does, but it opened up literally billions of sites worth of content that a desktop user could only dream about. Now the web has created this whole new problem of trust, which cryptocurrencies solve, but at the cost of regressing 30 years in performance and usability.

But one could ask what is the current paradigm?

For example, you can view it as the desktop stopped evolving, or that we moved to the browser as a virtual machine hypervisor running whatever environment you choose (particularly true with WebAssembly).

The 90s were exciting because the desktop was seen as the center of the computing universe; these days the browser is the center and the desktop is a "me too!" paradigm.

One could argue we got "stuck" or one could argue that evolution shifted to an internet first paradigm with more security in mind.

I prefer the '90s overall. There are good points to the modern web/internet world, but given a choice the '90s design is a better paradigm. Of course this assumes that one does their respective paradigm well, there were a lot of bad designs in the '90s that are worse than today's equivalent. However I contend that if effort had been continued in the '90s direction the result would be better.

Again, there are some major points in favor of the current internet/web world. For any "program" which you will use rarely it isn't the worth the cost to install the program.

We have two dominant mainstream paradigms.

We have the browser. And we have the app store.

Arguably, for better or worse, the desktop shifts to a combination of these and probably converges with mobile for mainstream users.

No it wasn't. The 90s was just intel and microsoft eating the market and killing innovation from competitors. Wintel easily set us back 20 years.

Indeed. Looks aside (although I liked them too), OS/2 was such an unbelievably good user OS. I wasn't programming enough at the time to know if it had a good developer story or not, although I kind of dug REXX.

Workplace Shell was pretty innovative, and the only firm I know of that took advantage of it was Stardock.

https://en.wikipedia.org/wiki/Workplace_Shell

https://www.stardock.com/stardock/articles/article_sdos2.htm...

and its follow up OS/2 Warp.

Which I believe is the only operating system advertised in the Super Bowl.

IBM's windows replacement wasn't so bad in my very limited usage of it. (I used it as the only scanner drivers we had for a scanner at IBM was for a OS/2 warp machine...)

It also doesn't really address the question, why Copland failed, which likely had a lot to do with Apple's management culture rather than the technology they were attempting to build.

In this vein, I think they tried to do too much at once. They should have learned their lesson with the PowerPC. They had two tracks, one was trying to implement a new OS. The other implemented the 68k OS on a simulator. The first track was way late. If Copland could have released just a protected environment at first, and allowed people to start writing for it, they could have added all the rest later.

If you look at the Copland technical docs, they describe an OS with modern underpinnings but running the Mac UI as a single process on top of it (https://en.wikipedia.org/wiki/Copland_(operating_system)#Cop...). Developers were supposed to put as much functionality as they could into background processes/threads that would benefit from preemptive multitasking and protected memory.

Amusingly, classic Mac OS ended up sort of close to that if you squint. It had a "nanokernel" that ran tasks preemptively and even supported multiple CPUs, but like with Copland the entire UI ran as a single "blue" task. The main difference from Copland as far as I can tell is that non-UI tasks were heavily restricted in the OS APIs that they could call; for unsupported APIs they had to send a message to the blue task and wait for a response. More details at http://mirror.informatimago.com/next/developer.apple.com/tec....

The premise is a stretch. Arguably, general purpose computing today is either nix or VMS-derived--and I'm not even sure those are are sufficiently different in underlying model to be completely separate operating system trees.

That said, I can buy Windows NT as sufficiently distinct to be a unique 1990s OS. But Linux is clearly a *nix and OS X is as well--UI and integration notwithstanding. Sure, you can pick NeXT Step and Linux and go "90s!" but they're clearly part of a much earlier tree.

And, if you bring in mobile, Android clearly derives from Linux. I don't know enough about iOS internals to identify where it sits in the OS tree.

iOS derives from OS X.

Indeed so.

And NeXTstep isn't a 1990s OS. It's a 1980s OS. v0.8 first demoed 12 October 1988 when the NeXT cube was launched; v1.0 shipped 18 September 1989.

NeXTstep influenced the Windows 95 UI in some ways -- the shaded 3D look, the idea of a fixed panel across the screen which could be both an app launcher and an app switcher.

But NeXT probably got that from Acorn RISC OS, which was shipping before NeXTstep was ever shown.

I've written about that, too: https://www.theregister.co.uk/Print/2013/06/03/thank_microso...

Agreed, the premise here is in my opinion pretty wrong. While it too would be a little hyperbolic, I’d be much quicker to argue the opposite.

Also, how successful other OSes were or weren’t at attracting an install base during the 1990s is very tangentially related to why Copland failed.

Slightly related: I’ve always wondered what Apple might be like today if Gassée had succeeded in selling BeOS to Apple instead of Jobs with NeXTSTEP. Probably a nice headstone in the Silicon Valley graveyard next to Sun, SGI etc, but interesting to consider.

Yes. To paraphrase Ray Noorda, it'd still be dead, but it would have been a much more interesting death.

Oh my goodness, just think of the eulogizing of NeXT that we’d be doing here on Hacker News.

But who knows, maybe in that alternate timeline Sun succeeds in making a Solaris for the masses, and Linux becomes an obscure footnote. Some flavor of BSD ultimately becomes the oddball alternative to Windows (which dominates) and Solaris which is the runner-up developer favorite.

Dead.

Apple almost died the first time mostly because Gassée went for margins instead of market share when he was at Apple.

And then BlackBerry or Microsoft CE ends up launching the mobile revolution. Oh dear.

Nah, those were available for years and never reached anything close to iPhone/Android levels of adoption. It's possible that Android (the "better Danger" version, not the "iPhone clone" version) would have still happened, but it may also have languished without the iPhone to pave the way.

Agreed.

The original pre-Google Android was a Blackberry-killer, and I don't reckon that was a good way to go.

You can see some early prototype devices here: https://www.androidcentral.com/android-pre-history

As usual for Ars, it has a far more detailed history, with pre-1.0 screenshots: https://arstechnica.com/gadgets/2016/10/building-android-a-4...

You can see that, before the iPhone, it started out as a Blackberry clone, or something like it. And that, IMHO, was far to geeky a toy to change the world as the iPhone did.

On the other hand, maybe we’d all have physical keyboards now instead of poking at glass...

I remember being so enthusiastic about Android development and then the iPhone came along and was just 10 years ahead.

OS/2 as well. As soon as Microsoft split from IBM on OS/2 dev, NT progressed well. So, I wouldn’t call NT a failure as it continued on as the well liked Windows 2000 and parts were in XP.

NT didn't fail, it's still going in the form of Win10. But it's very much built along the lines of VMS. Which was the observation in the parent - the radical experiments failed and the Unix/VMS OSs survived.

BeOS was largely POSIX compliant and that still failed.

I think the answer to why some platforms failed and others didn’t is a much simpler one: partly due to the aggressive business tactics from their CEO and partly due to luck.

Linux is an outlier there but I think you can substitute the CEO effect with GPL however the luck element is still relevant.

If there is one thing the history of computing teaches us, it’s that a better product doesn’t mean a more successful one.

Firstly, I think I have to say 'define "failed".' The company is sadly dead and gone, swallowed by PalmSource. BeOS tech was used to build the ARM-native, multitasking, media-savvy PalmOS 6 "Cobalt" -- which sadly never shipped on any devices. PalmSource was then in turn swallowed by Access Corp of Japan.

These guys: https://en.wikipedia.org/wiki/Access_(company)

Still alive, to quote GladOS. It provides the Kindle web browser, for instance.

Second, BeOS has been reborn as Haiku, which is also very much alive, and includes what Be code it legally can (the Tracker, mainly).

Haiku is IMHO the most complete/most interesting desktop FOSS out there. Haiku is now self-hosting and recently entered beta, after a long gestation. There's very little manpower behind it, so progress is slow, but it is moving.

So, significant influence, I think it's fair to say. BeOS shipped, it sold, I reviewed v5 and it remains my favourite x86 OS ever written. (Yeah, I'm biased. Sue me.)

I think you’re forcing your definition of “successful” a little. I’m not going to disagree with you that BeOS was awesome; it still remains one of my all time favourite desktop OSs. But regardless it wasn’t commercially successful and thus isn’t sold to consumers any longer.

Haiku is an interesting one. I’d put it in the same category as ReactOS. It’s successful in the sense that it’s an open source project that’s under active development. However they’re still essentially just hobbiest platforms so I wouldn’t even rank them successful when compared to Linux on the desktop (eg Ubuntu, Fedora, etc) let alone successful compared to commercial platforms like Windows nor OS X.

It really is a great shame BeOS wasnt more successful though, it was an amazing platform (even without framing it in the context of the shit that was around at the time: Windows 9x and Mac OS 9). Sadly for Haiku, desktop computing has moved on and I just don’t think there’s any need for a classic BeOS desktop any more.

> Linux is an outlier

Linux was long the go-to OS for cheap servers running on cheap hardware.

When the dominant computing paradigm shifted to large arrays of cheap boxes (map-reduce -> Hadoop -> cloud) Linux was in the right place at the right time.

Linux was already pretty big by the time that had happened. Plus it was BSD that was originally favoured as the cheap goto OS by ISPs (before Linux really took off).

Without wanting to start a flamewar, I honestly think it was the GPL licencing that made Linux what it is. BSD was more mature, arguably better designed and was already in use and battle tested. But GPL forced collaboration a little more where and I think that really appealed to hackers.

(I’m not arguing that GPL is better nor worse than BSD/MIT/whatever. I have no strong allegiances with either side of the camp)

Yeah OS/2 was my first thought as well, that had a lot of support from IBM, albeit the folks running that show I don't think understood the market, users, Microsoft.

This was my first thought. I think the premise is founded in a kind of survivorship bias which is worsened by the fog of time.

Almost everything fails, you just remember the few that succeeded. There were thousands of Linux distributions, thousands of movies, millions of songs. Most of them failed and were forgotten.

Notably practically all 90s RISC operating systems were gone by the time the dot-com bubble burst.

Not really.

Some were ported to Intel. Others (HP/UX) became dedicated big iron operating systems. HP/UX and Solaris are still being updated and used.

Solaris is gone[1]. Illumos a fork of OpenSolaris still lives on however.

[1]: https://www.theregister.co.uk/2017/09/04/oracle_layoffs_sola...

> Solaris is gone

Solaris isn't dead. Oracle released version 11.4 in August this year: https://blogs.oracle.com/solaris/oracle-solaris-114-released...

The article you linked to doesn't say Solaris is gone either. It mentions large numbers of layoffs, but acknowledges that there is still a Solaris dev team in place (even if a significantly smaller one).

(Disclosure: Former Oracle employee, although I never worked on Solaris.)

i agree. there is a selective bias going on. like businesses, most attempts fail.