Porting DOOM To A Forgotten Apple OS

Apple hasn’t always had refined user experiences in their operating systems. In the distant past of the ’90s they were still kind of clunky computers that were far from the polished, high-end consumer machines of the modern era. That wasn’t all that Apple offered back then, though. They had a long-forgotten alternative operating system that was called A/UX designed for government applications, and [Keriad] is here to show us this relic operating system and port DOOM to it.

A/UX was designed in the pre-PowerPC days when Macintosh computers ran on Motorola 68000 chips. Luckily, [Keriad] has a Mac Quadra 800 with just such a chip that is still fully-functional. DOOM was developed with the NeXTSTEP operating system which can run on old Macs thanks to another tool called MacX which allows X11 applications to run on Mac. A version of gcc for A/UX was found as well and with the source code in hand they were eventually able to compile a binary. There were several hiccups along the way (including the lack of sound) but eventually DOOM was running on this forgotten operating system.

The main problem with the build in the end, besides the lack of sound, is that the game only runs at 2 – 3 frames per second. [Keriad] speculates that this is due to all of the compatibility layers needed to compile and run the game at all, but it’s still impressive. As far as we know, [Keriad] is the first person to port DOOM to this OS, although if you’re looking for something more straightforward we would recommend this purpose-built Linux distribution whose sole task is to get you slaying demons as quickly as possible.

Lotus 123 For Linux Is Like A Digital Treasure Hunt

Ever hear of Lotus 123? It is an old spreadsheet program that dominated the early PC market, taking the crown from incumbent Visicalc. [Tavis Ormandy] has managed to get the old software running natively under Linux — quite a feat for software that is around 40 years old and was meant for a different operating system. You can see the results in glorious green text on a black screen in the video below.

If you are a recent convert to Linux, you might not remember what a pain it was “in the old days” to install software. But in this case, it is even worse since the software isn’t even for Linux. The whole adventure started with [Tavis] wanting to find the API kit used to add plugins to Lotus. In theory, you could use it to add modern features to the venerable spreadsheet program.

The $395 software development kit wasn’t very common and there was also a Unix version of Lotus 123, but no one seemed to have a copy of that. [Tavis] eventually found someone who ran a circa-1990 BBS and had the data on tape. Turned out there was a hot copy of the SDK that he was able to use. But he noticed something else in the BBS’s list of files: the long-lost Unix version of Lotus!

An investigation found the installer used TD0 files which took some research. Luckily, a utility exists that can convert these to raw disk images. Inside was a very large object file. Apparently, in the days without dynamic loading, that object would be linked with plug in modules to install them.

The object file had all of its debugging information intact which shed a lot of light on the program’s internal operations. The old executables used COFF format but it is possible to relink it to an ELF file. Of course, it isn’t just that easy. [Tavis] wrote a small program to remove the old-style Unix system calls so they could be rerouted to Linux system calls. Some calls just pass through, but others need some translation due to differences in things like structure layout, sizes, and alignment.

In the end, it all worked but didn’t have a valid license. However, [Tavis] felt like since he did have a license and the software is abandoned, he was within his rights to crack the license check.

We are well-known abusers of spreadsheets around here. Of course, we aren’t the only ones.

Continue reading Lotus 123 For Linux Is Like A Digital Treasure Hunt”

Solaris Might Be Free If You Want It

There was a time when “real” engineering workstations ran Linux Unix. Apollo and Sun were big names and Sun’s version was Solaris. Solaris has been an iffy proposition since Oracle acquired Sun, but Oracle announced last month that you can download and use Solaris 11.4 CBE free for non-production use.

Do you care? If you ever wanted to run “real” Unix this is an option although, honestly, so is Free BSD and it probably has better community support. On the other hand, since you can virtualize a machine to spin up, it might be worth a little time to install it.

On the other hand, if you have an old SPARC machine — this could be big news. We aren’t sure how far back the hardware this will support will go, but this could be just what you need to breathe new life into that eBay pizza box from Sun you’ve had in the basement. Of course, if you have an FPGA SPARC system, this might be interesting too, but we have no idea how much other stuff you need to implement to be able to benefit from Solaris.

Will you install Solaris? If so, tell us why. We are sure we won’t have to prompt you to tell us why not. In 2017, we thought we’d seen the end of Solaris, but apparently not. Maybe this will help those folks still on Solaris 9.

Run UNIX On Microcontrollers With PDP-11 Emulator

C and C++ are powerful tools, but not everyone has the patience (or enough semicolons) to use them all the time. For a lot of us, the preference is for something a little higher level than C. While Python is arguably more straightforward, sometimes the best choice is to work within a full-fledged operating system, even if it’s on a microcontroller. For that [Chloe Lunn] decided to port Unix to several popular microcontrollers.

This is an implementation of the PDP-11 minicomputer running a Unix-based operating system as  an emulator. The PDP-11 was a popular minicomputer platform from the ’70s until the early 90s, which influenced a lot of computer and operating system designs in its time. [Chloe]’s emulator runs on the SAMD51, SAMD21, Teensy 4.1, and any Arduino Mega and is also easily portable to any other microcontrollers. Right now it is able to boot and run Unix but is currently missing support for some interfaces and other hardware.

[Chloe] reports that performance on some of the less-capable microcontrollers is not great, but that it does run perfectly on the Teensy and the SAMD51. This isn’t the first time that someone has felt the need to port Unix to something small; we featured a build before which uses the same PDP-11 implementation on a 32-bit STM32 microcontroller.

Change Desktop Environments On… IOS?

While Apple’s modern operating systems may seem like they exist independently of the rest of the computing world, they are actually close cousins of modern versions of Linux. The primary link between the two is that Apple’s offerings are Unix-based and even though Linux isn’t Unix in the strict sense, it’s built to be extremely Unix-like. Plenty of Linux software is POSIX-compliant, meaning it is effectively compatible with true Unix. But what can we do with that information? Well, to start, we can run Linux desktop environments on top of an iOS install on your favorite iPhone or iPad.

To be sure, we will be filing this hack in the “because you can” category. [Torrekie], the creator of this project, has plenty of builds (Google translate from Chinese) where the boundaries between things like Linux and Unix are either blurred or nonexistant. In this particular project, a jailbroken iOS device is essentially gifted a ported version of XFCE which is able to run fairly well on iOS thanks to its compatibility with Unix environments. Details on how this was accomplished are sparse without a full investigation of the source code right now, but you can head over to the repository if you are curious enough to try this for yourself. [Torrekie] does note that this will only work with iOS devices that have been jailbroken using the “unc0ver” jailbreak only though.

To be sure, the relationship between modern Apple operating systems and Linux is about as close as modern Porsches and the Volkswagen Beetle, but either way the two are close enough to get interesting and impressive mashups like this project. For now only time will tell if using XFCE on iOS will be useful for anyone, but other projects bridging the gap between Linux and Apple are sure to be more immediately fruitful.

Compute Like It Is 1975: 6th Edition Unix Reborn

If you crave experiencing or reliving what computing was like “back then” you have a lot of options. One option, of course, is to load an emulator and pretend like you have the hardware and software you are interested in. Another often expensive option is to actually buy the hardware on the used market. However, [mit-pdos] has a different approach: port the 6th edition of Unix to RISC-V and use a modern CPU to run an old favorite operating system.

It isn’t an exact copy, of course, but Xv6 was developed back in 2006 as a teaching operating system at MIT. You can find resources including links to the original Unix source code, commentary on the source code, and information about the original PDP 11/40 host computer on the project’s main page.

Continue reading “Compute Like It Is 1975: 6th Edition Unix Reborn”

Full DIY: A UNIX Clone On TTL

Making a CPU or indeed a whole computer system from scratch using discrete logic chips is by no means an unusual project, but it’s still one that requires quite a lot of technical ability and understanding of how computers work. Similarly, writing a UNIX-like operating system from scratch is something that’s been done more than once, but which definitely puts the author in an exclusive breed.  Creating a CPU and computer system from discrete logic and then writing a UNIX-like OS for it? That’s definitely something new, but here’s [RobotMan2412] with both CPU and operating system to prove it!

The GR8CPU as he calls it is an 8-bit design with a 16-bit address space, making it equivalent to a typical mid-to-late 1970s 8-bit chip. He’s on revision 3 of the processor, and even makes the bold suggestion that it might be the most complex breadboard CPU ever made. That’s impressive enough, but to add a UNIX-like operating system makes it special.

While he has a real GR8CPU, it appears he’s also written an emulator with access to a disk filesystem, and it’s on this that he shows us the OS running. Don’t expect an all-singing all-dancing desktop OS here, instead it’s a kernel and very basic command line that’s just about able to run a Hello World. The kernel is hand-coded in assembler and is about 5 kB in size.

We look forward to seeing more of this project, and hope maybe he’ll one day soon publish the source. As a reminder that this is a perfectly capable platform for the job, here’s the original UNIX running on a vintage DEC PDP7.