Have You Ever Heard Of The Lobo MAX-80?

[Adrian Black]’s enthusiasm is palpable as he shows off something truly unusual: a Lobo MAX-80 computer from 1982. To call this machine rare would be an understatement, as the company folded soon after its release. The one shown here is the first one [Adrian] has ever seen, never mind that he had never even heard of it before.

Aggressively priced and only around for a short time, it’s unknown how many were actually built.

The MAX-80 was a Z80-based computer that was CP/M and LDOS compatible. As [Adrian] puts it, many companies and innovative products came and went during this time period. There was so much, and most of it has simply disappeared.

He was able to find information about the Lobo MAX-80 from advertisements, media coverage, reviews, and more (and he has thoughtfully uploaded everything, see the video description for links) and even pieced together a short history of a company that got its start making TRS-80 and Apple II disk drives before transitioning to producing their own machine. The MAX-80 was released in 1982, but sadly the company didn’t last much longer.

After sharing what history he was able to dig up, [Adrian] opens the unit he has and goes through diagnostics. It’s actually in remarkably good shape, and he’s eventually able to get it to actually boot into CP/M.

There’s still more work needed before he can put it through its paces, but getting a formerly completely unknown machine from the 80s operational is pretty wild. Watch the whole thing in the video below.

Continue reading “Have You Ever Heard Of The Lobo MAX-80?” →

2026 Retrocomputing Challenge: A Homebrew Computer In Only Three ICs

Homebrew computers don’t have to be retrocomputers, but [Just4Fun]’s all-through-hole, 68008-based “68k-MBC” certainly qualifies, so it is a worthy entry in our ongoing contest. While there are both “full” and “lite” hardware configurations, the three-IC “lite” configuration is what first caught our eye. Yes, three: the 68008, an SRAM chip, and a PIC microcontroller that acts as the ROM.

Software is provided by the suitably-retro CP/M68K, or standalone executables, which run on both hardware configurations.

There are four lights, but three chips in the “lite” version of the build.

The “lite” option restricts you to a maximum of 512 KB of RAM and a single serial port, but it looks like you still get I2C and the option to plug in an SD “hard drive” or RTC module however you configure the machine. Through the serial port, you can of course connect a terminal of you choice, or even use a thermal printer. The “full” version has two serial ports, if you want to do both. [Just4Fun] also has a parallel adapter lets you plug in printers with that interface as well. The demo video is below, but be warned that the text-to-speech narration won’t be to everyone’s liking.

We’ve featured other single-board-computers using the 68k before, but this one is a worthy contender in our contest, not least for the impressively low chip count. This contest has gotten oodles of entries, but there’s still time for yours: entries close October 27th.

Continue reading “2026 Retrocomputing Challenge: A Homebrew Computer In Only Three ICs” →

Sony’s First Computer

In 1982, desktop computers were coming into their own, and no clear leaders had emerged. But everyone knew they wanted a piece of the action. This led to, among other things, Sony’s SMC-70, which, frankly, for 1982, was a good-looking, if not oddball, machine. [Tech Tangents] shows the machine off in a recent video.

From the front, the computer looks more-or-less like everything else. But as you move backward, you can see this computer wasn’t another typical entry into the market. One of the things that was the hallmark of successful business computers of the day was expandability. The earlier Altair had the later-titled S100 bus. The IBM PC had the ISA bus. But in both cases, you had to open the box to plug and unplug cards.

Continue reading “Sony’s First Computer” →

Rosy Retrocomputing

Most of us are guilty of romanticizing the past. Do you long to be the captain of a tall ship? Just as long as you don’t mind weevils in your food, vitamin deficiencies, and death from an infection when there were no antibiotics. Want to be a medieval knight? Even worse. But surely, retrocomputing is as fun as we remember, right? Turn your computer on, and it comes up with BASIC! Ready for you to write your own programs. None of this GUI foolishness. Of course, this is just another example of rosy retrospection.

Even if you like BASIC or a similar language today, things have changed. You have a nice text editor, a fast computer, debugging tools, along with things like named functions, no line numbers, and modern control structures. None of those things were very common in the 1980s. At least, not on a hobby-grade computer.

Why am I thinking about this? Well, the Hackaday Retrocomputing Challenge is on, and it occurred to me that I wanted to work with some young students in glorious MBASIC on a CP/M machine I built and modified from a Hackaday project. Perfect, right? Many of us started that way, so why shouldn’t they?

But it quickly got old. Even a simple program gets bogged down with GOTOs and GOSUBs to mysterious line numbers. It made me remember the time back in the early 1980s, or maybe even the late 1970s, that I wrote a BASIC preprocessor to scan BASIC with no line numbers and produce proper source, converting labels to line numbers in two passes.

Continue reading “Rosy Retrocomputing” →

At Last! CP/M For Protected Mode

If you used a serious computer pre-IBM PC, there was a fair chance its operating system was CP/M. CP/M was a staple among 8080 and Z80 computers and while there were other versions, we’ll always associate CP/M with the Z-80. There was a CP/M made for the PC which used an 8088 (a hybrid 8-bit bus with a 16-bit 8086 core), but it was overwhelmed by MSDOS. However, there was another interesting version made for the 68000, and now [johnsonjh] has ported that over to create an early version of CP/M for 80386 protected mode.

The Z-80 only had a 16-bit address bus, so it could only handle 64K of memory. It was common to “bank switch” some memory, and CP/M Plus could be made to understand that (for example, you might have 32K of common memory and three banks of 32K memory; you could address one bank at a time). However, the 386 had a full-blown memory management unit that could remap physical 4K memory pages to anywhere in a program’s virtual address space.

Ordinary CP/M couldn’t handle that, but the Motorola 68000 had a similar page management model, so it makes sense it might be easier to port CP/M-68K to the 80386 than starting from the original, even though the instruction set for the Z-80 is conceptually more similar to the 80386.

What can you do with it? We don’t know. Presumably, it will allow you to use lots of memory. Historically, CP/M software from one variant would not run on another, so you’ll have to build anything you want to use. Of course, the real killer for lots of CP/M memory was multitasking, but that takes MP/M, and only about half of that is currently working. But we won’t be surprised to see it completed soon.

While CP/M skills won’t land you many jobs these days, it is a pretty good way to get mentioned on Hackaday.

An Unlikely Host For An 8080 Emulator

To emulate vintage microprocessor hardware, it’s normal to find a modern host that provides alongside the number-crunching grunt, sufficient physical connections to interface with its support hardware. Thus if you were shopping around it might be reasonable to pick something with a powerful core and plenty of pins. Yet to emulate an 8080, [Ted Fried] has eschewed both of these — opting for an ATtiny85, a microcontroller deficient in both pins and processing power.

This seemingly impossible feat is achieved by reducing the physical connection to an SPI bus and offloading the support functions to a Teensy. The emulation code is significantly optimized C, and includes a 128 byte cache to speed up matters. This delivers a speed claimed to be only very slightly slower than a real 8080 when booting CP/M, which is quite a feat.

We’re sure that CP/M enthusiasts will have fun with this project, and we especially like the full write-up. Going to the effort of making fake 1975 electronics magazine covers for the project really is going the extra mile, and we appreciate that. Meanwhile if you’d like one of your own, the whole thing can be found in a GitHub project.

If you’re not familiar with the 8080, maybe we can get you started.

CP/M Gently

If you are interested in retrocomputers, you might be like us and old enough to remember the old systems and still have some of the books. But what if you aren’t? No one is born knowing how to copy a file with PIP, for example, so [Kraileth] has the answer: A Gentle Introduction to CP/M.

Of course, by modern standards, CP/M isn’t very hard. You had disks and they had a single level of files in them. No subdirectories. We did eventually get user areas, and the post covers that near the end. It was a common mod to treat user 0 as a global user, but by default, no.

Continue reading “CP/M Gently” →