Build your own NeXT with a virtual machine
learn.adafruit.com
learn.adafruit.com
Years ago I acquired and refurbished a NeXT cube. They were certainly a distinctive-looking computer for the day, but I don't know that there was anything particularly special bout the hardware that was worth recreating. The software was the interesting bit.
A modern computer running the whole thing in emulation is not the same though.
Whereas for example an FPGA implementation, that’s in line with my idea of “build your own NeXT”. Even though someone might say, that’s emulation too. And they’d be correct in a way. But like, do you see what I mean?
“Build your own NeXT with a virtual machine”
Which may not be in accordance with the submission guidelines.
> A modern computer running the whole thing in emulation is not the same though.
>> Whereas for example an FPGA implementation, that’s in line with my idea of “build your own NeXT”.
But the OP is not that. IIRC, there were two distinct versions of NeXTSTEP: a 68k version for their custom hardware, and a x86 version for PCs. The OP is setting up VM for the latter (which given its age does not seem like a trivial thing, either).
So if you must have an FPGA version, it would be equally equivalent to have one that simulates a mid-90s IBM clone.
That would be acceptable, as you built a machine that functioned exactly like the original, running the OS on bare metal - not on unrelated hardware under emulation. That would fit my idea of "building" the machine as well.
Agreed though, the headline is a little odd. I was expecting something akin to that guy who designed and fabbed a new logic board for an SE/30. That would've been a feat, especially since those Motorola processors are so hard to come by now.
See this article that adolph linked in another comment: https://simson.net/ref/1993/cubefire.html
LOL
Maybe a pizmo macbook?
I have a SparcStation 20 with 512 MB RAM and the 24 bit framebuffer RAM expansion, this is a great machine for NeXTstep.
If you happen to have an hp PA-RISC machine, some models using the PA7100 CPU (e.g. the "Gecko" 712-series) are also supported and are really nice NeXTstep machines.
Vintage Apple hardware does not work with NeXTstep directly, but you can run Rhapsody (essentially NeXTstep for PowerPC with a System 9-like UI) on early G3 Macs.
The Motorola 88k-based NRW (NeXT RISC workstation) was unfortunately canceled when NeXT decided to leave the hardware business...
If you don't have a compiler set up on the PA-RISC machine, you should be able to cross-compile or generate a fat binary from ProjectBuilder on NeXTstep/intel.
http://tenfourfox.blogspot.com/2014/08/and-now-for-something...
Nextstep was also glorious. I supported a lab full of cubes and slabs.
But under the covers, the hardware other than the terrible magnetic optical drive was boring. There was only minimal hardware distinctiveness. The built in Motorola DSP was nice..ish, but the real revolution before and after NeXT was graphics. The non-NextDimension-equipped cubes were utterly pedestrian compared to things like the Amiga (before) and the SGI machines. Not long after the slabs shipped Apple shipped a Mac ii with a TI DSP on a card for accelerated 3D.
I’m a huge next fan but it was all the experience - excruciatingly terrible for the MO cubes to glorious for the color turbo slabs - which defined NeXT.
https://en.wikipedia.org/wiki/NeXT_MegaPixel_Display
The original MegaPixel Display was a monochrome 17" monitor displaying 4 brightness levels (black, dark gray, light gray and white) in a fixed resolution of 1120 x 832 at 92 DPI (just shy of a true Megapixel at 931,840 total pixels) at 68 Hz
October 1986 https://books.google.com/books?id=mzwEAAAAMBAJ&lpg=PA41&ots=...
Multiple 1024x768@16 cards in $2-3K range, and an absolute steal - $3K Number Nine 1280 1280x1024@256.
In 1988 you could buy 1664x1200 PC card + 19 inch monitor $2400 combo https://books.google.com/books?id=Cj8EAAAAMBAJ&pg=PA53&dq=Si... or ~$1K 15 inch 1mpix version.
https://www.artstation.com/marketplace/p/25vy/next-cube-rasp...
enjoy :)
I definitely thought the same thing being it was an Adafruit post and disappointed both times to see it was just a basic howto on running the OS in a VM. Still very useful knowledge if someone wants to play, but kinda can't help think they worded it that way to draw folks in. I was really hoping it was some FPGA or maybe even an MCU running an emulator, but alas, QEMU / Virtualbox is what they used.
Given the recent anniversary, maybe it would be apt to add a vintage looking sticker with red inked "This machine is a server. DO NOT POWER IT DOWN!!"?
https://home.cern/science/computing/birth-web/short-history-...
I didn't use it much (way too expensive for a PC, and not considered an engineering workstation), but I did get to play with one in a computer lab a short while. And later I used a bunch of open source window management and utilities on Linux that mimicked aspects of OpenStep.
The NeXTstep look was very legible and understandable, and stylish at the time. Compare to Mac of the time, or the later Win95. (Today you might be bothered by the wide non-autohide scrollbars with the stipple, the font aliasing, or the particular shade of gray. But you might find it more accessible than ad hoc brochure looks in a lot of UX.)
On the scrollbars, note that the buttons for the two arrows are right next to each other, rather than at each end, which made a lot of sense if the user is actually clicking on the buttons to navigate, and might want to change direction.
The hierarchical assemblies of lists in the UI seemed to come from Smalltalk browsers.
The desktop icons weren't just to represent programs that were running, like'd see on X at the time, or later in Windows 95, but are more like both launchers and navigation (and could be other things), and dockable. More like the dock in current Mac OS X, etc. (I thought of NeXTstep when I made my XMonad window manager setup, where I made commands that navigate to a particular kind of window, starting the program if needed, and a modifier key can be held down to create additional instances of some kind of window.)
Note that the Mac's trash can became a more environmentally conscious recycling bin.
I'm sure some people who used the NeXT heavily could point out many other points of interest.
"NeXT vs Sun"
Three minutes in, you know that Sun (he looks IBM) is going to get destroyed, not because of OO like the narrator later asserts, but because the requirements will leverage components that are bundled with NeXT, but not bundled with Sun.
This is running a mix of older NextStep apps and newer OpenStep apps. For example, there are two text editors: Edit.app, and TextEdit.app. Edit.app is the original NextStep editor circa 1989, and TextEdit is the OpenStep reimplementation circa 1995. You can tell if it's a newer OpenStep app because it draws Windows-style focus rings around the buttons and controls.
OpenStep became Cocoa, so OpenStep code looks very familiar to anyone who's done Objective-C development for Mac or iOS. NextStep code, on the other hand, looks very foreign to modern eyes (There are no NS classes. It's basically just plain C and AppKit classes like Window, Button, View, etc.)
The TextEdit source code is included in the developer examples folder, written by Ali Ozer. Apple would continue to include the latest TextEdit source code with Xcode up until about OS X 10.9, if I remember.
This version of TextEdit is cross platform, so there's plenty of #ifdef WIN32 code.
There's no NSDocumentController, so there's boilerplate in the app controller, like checking if documents need to be saved before quitting, that a modern implementation would no longer need to worry about.
If you're old enough to remember using Xcode 3, prior to the Xcode 4 redesign, you probably found that IDE quite strange and difficult to master (I miss Xcode 3, myself). Xcode 3 was a descendent of the NeXT Project Builder circa 1996. Playing around with the older, and much simpler, Project Builder makes it easier to understand why Xcode 3 worked the way it did.
I do still have stacks of NeXTStep CDs sitting in a closet though. I used one of the Intel version ones a couple years ago to install a copy on VirtualBox like this guide is showing. Fun to screw around with it, brought back fond memories of my days in school using an original NeXTstation.
Steve Jobs actually paid a visit. When he saw the demo he said "That isn't what we had in mind." We thought he was kind of thick, that he didn't get it that when you have a cool product then users are gonna user and figure out all kinds of different things to do with it. Later it became clear that he was all about controlling the user experience, so seeing what we did was very contrary to his way of thinking.
What Jobs did was incredible and I absolutely believe he was a visionary. But I hadn’t really considered the trade-off. That he would almost require tunnel vision to do what he did. A kind of product design near(far?)-sightedness.
In hindsight this is obvious and probably true of most of us but your anecdote is a great example.
I do think the Web Platform makes a pretty bad (foundation for a) UI toolkit, at least judging from the results. I think the amount of awkwardness in JavaScript is just plain unreasonable. I’m also disappointed by how badly the practices of the modern Web accomodate, well, viewing static text and images retrieved over the Internet. Various JavaScript libraries and approaches seem to pass by so fast I get dizzy if I look. (The last point would probably disappear were I to fully immerse myself in Web programming, but I just don’t like it enough for that.)
And yet.
It seems that the people making all these frameworks and producing unjustifiably heavy blobs of JavaScript in order to display a photo... Are gradually encountering and solving, in a practical context and with real-world feedback, a lot of genuinely difficult problems—problems which often have only been considered in an academic context, and then not with an overabundance of results.
It’s not that they go out looking for difficult problems to solve—unlike academics. They frequently don’t even realize the difficulty or the existence of the problem at first. It’s just that they start with a reasonably complete solution for a small problem area, go right to the boundary, and push. Pretty soon the boundary reaches things that were previously only attacked with Grand Generalized Solutions, found hard, and left unsolved. Yet they need them solved, so they push further. The flood of frameworks and best practices occurs because they are iterating.
This process produces warts. I mean, of course it produces warts. It cannot help but produce warts. In a setting that also prizes backwards compatibility, some of those warts survive long enough to become functionally immortal, and so the survivors accumulate even if most warts are eliminated very quickly. Eventually we reach a point where we can only look back at a five-meg Opera executable and weep.
This process also means that some of the new best practices are practically indistinguishable from the old ones. However, that is not in itself a condemnation: a lot of people changing their minds can very well happen a function at a time, a default at a time, even a function name at a time. Some of those changes—maybe even most of those changes—are still noise and passing fads. But they are fads of a specific kind—they are generally not sticky: because iterating is the (social) norm, whole industries and schools of thought don’t get founded around a single supposedly universal solution, and giant edifices of millions of lines and man-centuries of effort don’t get erected around a suboptimal approach (see: XML). As fads go, I’d say these are pretty mild.
So what are some of the hard problems the Web people are solving or found themselves having solved?
Native code generation for dynamic languages. (Tracing JITs pretty much won, from what I can see, yet it seems that nobody expected that, not even the Self people that did much of the foundational work in an academic context before.)
Ergonomics of a fully asynchronous programming environment, up to and including system calls. (Again, cooperative concurrency seems to have pretty much won here, yet it wasn’t that long ago that the BeOS approach of preemption and shared memory seemed a plausible solution for responsive UIs. While people were already doing cooperative threads when the 6502 was the new hotness, my machine has IndexedDB but neither scheduler activations nor transactional memory.)
Model that can represent most of the meaningful organizational semantics in most of the documents. (The problem isn’t inventing a model, the problem is obtaining enough data to converge on the right one. HTML5 is a resounding success in this respect; from what I can see most of the other document preparation or processing systems either had the document author code a bespoke structure, fell back to presentation details, forced everyone to adjust their documents to match the limitations by administrative mandate, were basically unusable, or all of the above.)
Declarative, non-Turing-complete styling that’s still flexible enough to make following the semantic model above feasible and even pleasant. (I like XSLT and dislike most templating, but CSS selectors feel so much more carefully designed than XPath. I suspect having to do efficient and even incremental implementations from the start has something to do with it. I still want a neat mathematical model, like maybe tree transducers, to tell me what I should and shouldn’t include in a styling language.)
Practical, interactive reflowable text layout that can do modestly non-trivial typesetting. (TeX can do some things better but basically can’t do cutouts at all without hardcoding sizes, and it’s a language powerful enough you can basically only execute it. Roff does much less. Everything else either requires babysitting by a human when changing layout widths or would make a typographer from half a millenium ago cringe.)
Resolution independence including on pretty low-resolution devices without fuzziness or glitches and with support for zooming in while preserving in the layout. (The CSS “pixel” is a hack but the approaches in native app ecosystems are absolutely infested with much worse hacks. I wonder how many people on Earth understand the rounding code in a major browser.)
Understandable, even intuitive GUI conventions for (extremely) untrusted applications. (It starts with powerboxes but ends with very subtle tricks like a timer on the “Open” button. Still no petnames for some reason.)
Applications that work offline yet can be used immediately without a user-visible installation step. (Turns out you just had to make the online case the default one and get it wrong a couple of times, and you can give people enough of a framework that they are able to make the major effort required to get it working if they have the motivation.)
Graphical user interfaces that are general enough to do almost anything yet are not a maze of twisty little assignments and repaint calls. (I’ve been watching the progress in FRP since about 2010, and while the Web variations are all pretty kludgey, they’re still a damn sight better than everything I’ve seen atop a native UI toolkit. I get the impression XAML might be a contender but haven’t been able to find a description of how it deals with the difficult stuff; it’s also purely presentational from what I understand.)
Each of these purported solutions has flaws and can be disputed, and I’m sure people can point me to prior work that’s more principled or does some aspects better (please do!). My point is that all of the questions are very difficult, mostly unrelated to the Web’s natural monopoly position, and yet for every one of them the Web ecosystem approach of dumb but dauntless iteration has done the state of the art a lot of good.
1. I'm not sure if this was pre- or post-release of NeXTTeX
Apple was the only computer company taking advantage of human psychology in such a deep way to make computers easier to use. To some extent they still are, but for decades the Macintosh was pretty much the only computer truly approachable by normies. Mac OS X compromises that approachability in a few fundamental ways (and it's getting worse with the iOS-ization of everything).
7 broke a bunch of other excellently-discoverable stuff. The replacement for the unlock slider was especially far into obviously-a-large-step-backwards territory.
The tradeoff against that of course was that you could not open the same folder in two different windows. With OS X, Finder implemented Miller Columns[0] (as taken from NextStep), so that ended spatial Finder, since windows could no longer be associated with particular folders.
Personally, I'm a huge fan of Miller Columns as I find the easy hierarchy great as part of the "operating system is the dev environment" approach, but if I worked on more chaotic art projects perhaps I'd like spatial finder more. Either way I use Windows now and most of the alternative file managers don't seem to integrate into the OS well, so I get neither lol
I want my file-browsing window to maintain a consistent presentation as I navigate. I don’t need each folder to open another window; that makes me crazy, and was one of the things I hated about OS 9 when I moved to the Mac in the late 90s. To me, the shifts under OS X — mostly, the unixy (BSD-y) underpinnings but also changes like the abandonment of the spatial Finder — made it WAY better.
What would have been really nice would have been to get a clear, visually-distinct instance of both; to get a really clear "this is a file browser" tool in the finder, and a really clear "this is a folder" tool in the finder.
They're both really useful tools to have - what was awful wasn't gaining a file browser, but was how they mixed file browsing and folder viewing into this awful pea-soup thing that damaged a bunch of the value points of both tools.
I really like having a file browser, but there's a LOT of value to having something that treats folders as individual, stateful documents.
Something else, anecdotally: NeXT people never used the workspace to actually do anything. They always went to the command line to copy/move files and do other file management things. My takeaway was that the workspace was mainly a proof of concept.
• Only one instance of a folder could be open at once. If you tried to open more than one copy, it would bring the previous one to the front, instead.
• the act of opening a folder would always consistently draw an animation zooming from the icon you'd double-clicked on, to the final open copy of the folder.
Of these 3 promises, the first one was the insanely-great, "magical" one. It ends up tapping into a really powerful aspect of human memory. It has to be absolutely consistent on the OSes part to work (nobody can EVER move your cheese), but if it is consistent like that, then it feels like it unlocks a weird superpower, because you can always find things instantly based on where they are, physically. It's like going from O(log(n)) to find something to just O(1).
It's like having a "cluttered" (but personal) toolshed, where nobody else would have moved anything around. If you have that guarantee, you don't need to waste time "searching" for something, because you know exactly where you put it when you left it there.
Humans for some reason all have extremely good memories on this front; some are better than others, and there's probably some "learning differences" science on this, but as far as I can tell the floor for this capability is really, really high. Even those of us who are "bad" at this are really, really good.
--
The second item, "only one instance open" is the one that had genuine downsides. Opening multiple views of the same document is a very useful paradigm, which I do all the time in code editors, and in photoshop.
Something that could have been a great compromise, which I think apple really dropped the ball on, would have been having a much stronger separation between two concepts, that in OS X are (practically speaking) really blurry/similar: a "folder view", and a "file browser".
A folder view would have retained all the "spatial finder" behaviors, but a file browser would have looked dramatically different, and allowed you to have all the benefits of opening multiple document views, without the confusion.
The problem with multiple "actual folder view"s being open is you never can tell which one is the master copy for setting the position/view-settings/size. One of them is, but the OS doesn't give an indication. So it really screws with that positional memory thing - you'll have one on the right side of the screen, and have another on the left side, and your brain will "pin" both of those in your memory, but when you go looking for the one that was ephemeral, you can't find it, because the one that got stored was the other one.
Sure, it was all old and ugly by today's standards, and a big step backwards overall from the Plasma desktop I was used to, but it felt really good to use.
The whole GNUStep ecosystem is crazy impressive too, and idk the history around it, but I assume interest for it died off a long time ago. Which is a shame, because having that development environment on a modern (free as in freedom) desktop would be awesome. Objective-C gets a lot of hate, but IMO it's the better answer to a C successor than C++ was, as it's literally just "C with classes" and none of that other bloat.
But apparently development for GNUStep is still alive (last stable release was ~2 months ago), so maybe there is still hope that it will take off one day!
Eventually switched to XFCE near the end of my time with Gentoo, and kept that when I changed distro to Ubuntu.
Unfortunately I changed positions and needed a DE that other people could use without getting confused, so I switched to Mate and made it act like Windows 10.
The hate for the amount of @, [ and ] I have to type, specially in non-US layouts is deserved.
That's the cool thing about Linux, you don't NEED your GUI to be a noisy nightmare (looking at you KDE). All my menus are context mouse menus. I don't do start menus, 1 level deep, with fewer than ~8 items, otherwise i'm using CLI or launching it via Xterm. Of course, apps are still at liberty to look like crap!
Rob Blessin at Blackhole can probably help you with black hardware if you're into that. (NeXT non-ADB keyboards are a pleasure to use for a while).
There are also some of us who are still building and running native X86 boxes to run Openstep natively.
If you (the general you, not you specifically, since you probably already know this) get your hands on a NeXT keyboard and want to use it with a modern system, Adafruit has a guide here for building a USB adapter with an Arduino: https://learn.adafruit.com/usb-next-keyboard-with-arduino-mi...
I had three big problems with the NeXT systems.
One was the MO; that was dire and terrible and they should never have shipped it. This was very rapidly fixed by adding HDs to every system as soon as we realized what boat anchors the MO-only systems were.
The second was the poor HW quality of the mice and keyboards. They simply broke a lot more frequently than the PCs, Suns (even the cheap pink/grey ones that I've forgotten the name of), SGIs and Dec systems.
The last was that we were an AFS university and the NeXT systems, if you accidentally browsed the AFS top level directory, would hang the browser for at least 30 minutes. Super unpleasant if you needed to head to class since a locking screen saver did not kick in even after the browser recovered. As a side effect, we'd have students yanking the power cord which itself was not always something that the HD slabs recovered from.
That said, I loved them, everything about them, and there has never been anything like that. The Sun-vs-NeXT thing was night and day.
But it wasn't a problem, because if you typed "Shift+Escape" it would translate to the tilde character, just as if the back-quote/tilde key was in its proper location.
I always thought that was a clever touch.
I think his company is mostly a single-person operation, so I would expect response times sometimes a bit longer than what you might be used from larger companies.
It's at my friend house now, he just managed to revive it after assorted false starts over the past few months. I have yet to actually see it running myself.
In hindsight, one of the things that made the NeXT, or more specifically, NeXTSTEP amazing, was what it could do given the hardware of the day.
The stand out was Display PostScript. What an absolute marvel of the time. That it could actually perform. Here was a system with a full boat windowing and GUI system, built on the full PS rendering model (INCLUDING the alpha channel), in real time, with a few MB of memory and a 25MHz '040. When you dragged a window. You dragged the window. The entire thing, not just a frame. That was a big deal.
I remember the heresy of people posting "rich" news poss to USENET using the whatever the news application was called in the day. This was before there was a MIME standard, just making stuff up everyday.
I think it would be a marvel to have the original source code ported, straight up, "bugs and all" to modern hardware.
Specifically thinking having NS ported to an off the shelf Raspberry Pi. I don't know if we have anything like that today. Creeping features have exploded...everything on a modern *NIX system. I don't think you can run XClock in 8MB of RAM today.
If NS was usable (I won't say it was fast, my memory doesn't go back that far, and after seeing several vintage machines, none of them were "fast", we just didn't know any better), just imagine how usable it would be on something even as small as a modern Raspberry Pi.
But it was a great machine. It handled my USENET and email feed over my 2400 baud Hayes Smartmodem with aplomb.
Not original NS, but GNUstep runs on the Raspi.
Install scripts here: https://github.com/plaurent/gnustep-build
> If NS was usable (I won't say it was fast,
NS was definitely more than "usable", it seemed very snappy at the time.
GNUstep runs very nicely on the Raspi.
Indeed, it's just that I've become quite jaded when it comes to computer speeds. All of the older machines were "fast" or better back in the day, but we only had other current machines to compare them too.
My friend, who has my NeXT, also has a G4 Cube. That thing waking up from "sleep" is GLACIAL. It just takes forever. I'm sure it was snappy and "fast" at its time. Today, perhaps, not so much.
But, still, it was a great testament to what could be done on such limited hardware.
I have to admit, setting this up was kind of a pain in general and I am not sure if it is worth the trouble. Maybe someone can give some examples while it might be? I personally wanted to take a look at Lotus Improv, but could after setting it all up not find a version for intel. I guess there never was one?
What happened was lighthouse design came in and built an exact clone of improv called quantrix. The manuals were interchangeable - I’m actually learning them now.
I bought a boxed copy of improv and quantrix manuals. It is /excellent/ we really have a lot of excellent ideas in our computing past.
If you want a copy of the lighthouse apps (they gave away licenses when sun bought them in 1996 or so. ) check out next computers.org They have a file section.
Improv 2.0 was only available for windows x86.
Lighthouse design quantrix for nextstep is available on m68k, x86, hp-parisc and sun hardware.
Then there’s an offshoot of lighthouse design quantrix which is quantrix modeller written in Java and available for windows and Mac. It costs $2500/year.
I’m learning improv on m68k and quantrix(the manuals interchange freely) on m68k/x86.
Programs were called apps long before NeXTSTEP existed.
Programs were called "applications" long before NeXTSTEP existed, but not "apps".
"Apps" was mainstreamed primarily by the iPhone and its App Store ecosystem.
https://trends.google.com/trends/explore?date=all&geo=US&q=a...
It was in common use with the Digital Research GEM desktop in the mid '80s (which used a .app suffix for applications), but was not particularly unique to GEM.
"App" however dates from at least 1981.
https://www.osnews.com/story/24882/the-history-of-app-and-th...
I heard a few years ago that Intel Atoms are basically supercharged 486s.
the audio output hardware only operated at 22khz when in stereo, if i recall correctly... however, the presence of the mc56k dsp made realtime resampling of any stream possible without burdening the mc68040 cpu.
perhaps the most interesting component of the next hardware was the "geekport" which was some oddball connector, like a db-19 or something that was a mix of ttl digital lines and analog in/out attached to a/d and d/a that were convenient to the dsp.
https://learn.adafruit.com/build-a-bebox-with-beos-and-virtu...
I haven't tried running NeXTstep in qemu recently, but I suspect it might simply work today.
The Previous emulator for "real" black 68k-based hardware that is mentioned briefly in the article is actually much more fun and also allows you to run 68k-only software such as Lotus Improv - http://previous.unixdude.net
I am a one man shop these days for the most part and well you can see hundreds of NeXT projects I've worked on at youtube.com/robblessin ,
I'm compmuterpowwow on eBay and blackholeinc.com is my perpetual disaster of a website.
When I started the website it was basically a very tiny web , as Sir Tim Berners Lee is one of my customers, I repaired his NeXT cube https://www.forbes.com/sites/danielnyegriffiths/2012/08/10/s... , a lot of war stories fairly sure between NeXT, Alembic and incarnations of leading to Black hole , we actually sold stuff on the Web when most people had no clue what it was lol. I we inadvertently invented spam , when we had the bright idea to send demos of the solid Thinking Modeler using NeXT mail to the University of Wisconsin and it replicated itself a whopping 3mb file bringing their 300 baud network down , oops . Not what we intended to have happen , however when the someone with a NeXT actually completed the download and figured out what it was they thought it was cool. Everything before then involved paper cuts stuffing envelopes with brochures, we evolved and set up a website with downloadable software links http://www.blackholeinc.com/catalog/index.shtml .
I saw acomment below on the original optical drives , they were and are crap , I've had them actually catch fire from the laser igniting the dust lol , then they turned the cooling fan around not sure if it was an improvement. It is possible to repair them now .... the hardware improved and NeXT was the first company to distribute software on CDrom hence the Sony 1X drive , first computers with CD Quality sound card and 56001 DSP , you can even boot them up as a Mac running up to version 8.1 . When I Tunes crashed fortunately I had the web objects software they needed to update it .....
Sorry to crash the party with a rant but I'm mainly at NeXTcomputers.org or NeXT Computer Enthusiasts and have a lot of cool vintage hardware not just NeXT . Apologies for the rant.
Best regards Rob Blessin