I can't say I'm wild about a world where Digital Research won. When they were dominant with CP/M, the tools and documentation were bad to the point where most machines had Z80 processors and DR only provided an 8080 assembler, so you had to DB significant bits of code to get the missing opcodes. Developing RSXs to access bank-switched memory under CP/M 3 could have been so much easier with a few examples and perhaps debugging tools. MS/DOS was just so much easier.

> But the bigger problem was software piracy. Piracy was common on the ST, and that made developers less enthusiastic to continue ST development

Not so sure about this. The Atari/GEM combination was very popular with musicians for MIDI, and I don't think there was so much piracy, or at least not compared with other platforms of the time.

The reasons I didn't develop anything much for Gem - a) It was quite difficult b) Not well documented c) I was too busy playing Dungeon Master.

I think many others may have similar thoughts.

I only used GEM in the form of Xerox Ventura Publisher. I used it to write all my undergrad papers.

It ran quite well on my 286.

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

Apple sued DRI, which resulted in the crippling of GEM, the glaring one I remember were static windows. You heard that right, windows were not resizable but had fixed screen locations in the PC version.

Thankfully Atari licensed GEM for their 68000 machines before the lawsuit, and wasn't affected by these changes. The Atari ST (Sixteen/Thirtytwo) was very Mac like at the time. It even ran the Mac OS from Apple ROMs (Spectre 128 and Aladin) on its much cheaper hardware.

I've been on a bit of a rabbit hole with Digital Research in the last few days, specifically because I am utterly fascinated with Concurrent DOS.

I played with Concurrent DOS (and later MultiUser DOS) in PCem and I was utterly amazed. I hadn't realized that there was a preemptive multitasking operating system available to consumers as early as the mid 80's outside of AmigaOS.

I read the Wikipedia and I kind of understand why it didn't catch on, but man I kind of wish DRI (and Gary Kildall) was still around. I suspect if they were, they would have continued to make stuff that was at least interesting.

GEM on the PC was... ick... compared to on the Atari ST.

But the problem with GEM on the Atari ST is that in order to cram it into the 192KB ROM they ripped out some goodies like proportional font support which ended up being in an add-on called "GDOS" which was buggy, used up RAM, and most people didn't have it (it came with things like DTP software etc).

In general this was always the problem with the ST. The Tramiels shipped it early and cheap and awesome and I loved mine ... but then didn't pay enough attention to software updates until it was too late and the world had moved on. Jack Tramiel never really understood the value of a good software platform IMHO.

In the early 90s they seemed to learn the error of their ways, hired some talent, and released full multitasking re-entrant versions of TOS/GEM ... but too late.

GEM's architecture itself underneath actually was clearly built for a mulitasking architecture complete with message passing between applications (via AES application msg send / mailboxes) etc. It just came down to failure to iterate.

Also the article mentions DR "hiring some people from Xerox" but in fact fails to note that the actual original architect and author of GEM itself was hired from Xerox (Lee Lorenzen). He joined up with DR because he tried to pitch Xerox on porting their Star office concepts down to PC-class hardware and they didn't go for it. His pitch video can actually be seen here:

https://www.youtube.com/watch?v=EMBGRZftS30

Lorzenen later left DR and created Ventura Publisher.

> One could argue DRI bowed out too soon. Then again, it’s questionable whether it would have won against Windows anyway. Microsoft was the larger company and had OEM agreements with all of the major PC makers.

Well, it is also that Windows even at version 1.0 was much more capable than GEM. Better documentation, better tools, better API and better functionality.

GEM was really just a shell over DOS and applications were actually DOS programs that called a special interrupt handler to make API calls. While this allowed any language that could make EXE files and call interrupts to be used to make GEM apps, it also meant that GEM inherited all the limitations from DOS, like the inability to run multiple applications at the same time (DR did eventually make GEM/XM that allowed switching between applications but it was still only one application active at any given time). Windows meanwhile not only could run multiple applications, but it also had a software-based virtual memory system that allowed applications to swap in/out both data and code to fit in the available memory (this required custom compiler support so, unlike GEM, you couldn't use any old compiler but on the other hand it you could make more complex applications).

The GEM API was also very barebones, you could create windows but all you could do with them was to draw inside. Dialog boxes were a completely separate thing that could take a tree of "objects" to draw inside them but even then the functionality was limited (the object types are hardcoded and while there is a "custom" type, all it does is provide a callback for drawing). You could work around some of the functionality by implementing some of it yourself - for example there is a call to draw an object tree (object trees are actually a flat array of fixed size structures where the first three fields define 16bit indices inside the tree for each object - this probably saved some bytes of memory at the cost of flexibility loss and TBH the extra bytes added for the code to work with the tree probably ate back those saved bytes, if not made things worse) so i think (never tried it) you could draw buttons, etc in a window when you receive the WM_REDRAW message but there is no event message propagation.

Meanwhile on Windows everything is a "window" in a window tree with a consistent approach to how things are handled. On GEM everything is a special case.

I get the impression that the GEM developers basically had some idea of what their desktop would look like and implement the functionality to do just that and nothing else with little room for flexibility or later expandability.

EDIT: also the graphics functionality was very limited, e.g. with hardcoded colors. Here are some GEM API docs in case anyone is interested:

https://www.seasip.info/Gem/vdi.html (low level API, draw graphics, input devices, etc)

https://www.seasip.info/Gem/aes.html (relatively high level API, make windows, define dialogs, messages, etc)

https://www.seasip.info/Gem/aestruct.html (some structures)

https://www.seasip.info/Gem/aesmsg.html (event message types)

There's now a version of GEM you can run on a Lisa. But 68KMLA is down so I have no easy way to link to the relevant thread. :(