retrocomputing

384 Articles

A Retrocomputer Disk On A Chip

March 30, 2018 by 28 Comments

There have been a lot of different mass storage methods over the relatively short lifespan of the computer. Magnetic tapes, drums, all sorts of disks, and flash memory have each had their time. Each of these new innovations required some time to become easy to use. One of the early attempts to simplify using flash memory was the M-Systems DiskOnChip device. Looking like a standard 8K JEDEC-compatible memory device, it actually provided access to a flash disk drive ranging from 16MB to 1GB. [Smbakeryt] bought some of these devices and built an ISA board to provide a disk and clock for the old 8-bit bus. You can see a video discussion about the device below.

SanDisk bought M-Systems and discontinued the devices back in 2007. Of course, you can still design flash memory into your system, but the simple and efficient interface of the DiskOnChip is no more. It is a testament to how simple the interface is that the schematic for the little board fits on a page, including the DS12885 real time clock.

Continue reading “A Retrocomputer Disk On A Chip” →

Apple One, On FPGA

March 29, 2018 by 17 Comments

Today, Apple is known for iPhones, iPads, and a commitment to graphical user interfaces. But that wasn’t how it all started. The original Apple was a single board computer built around a 6502. In 1976, you could snag one for $666.66, but you needed to supply your own TV, power supply, and keyboard. [Alangarf] didn’t have an Apple 1, but he did have a 6502 CPU core for FPGAs from [Andrew Holme] that he fleshed out to an Apple I clone with a VGA output and PS/2 keyboard port. The project works with either an iCE40 board or a Terasic DE0 board. You could probably port it to other similar FPGAs.

This is much more practical than trying to find an original, as Apple bought a lot of the old boards back and destroyed them. According to the Apple-1 Registry there are only about 71 of the boards still in existence, and that’s with the annotation that 4 of those may be lost and 8 might be duplicates. We’ve heard that of those there are only six that actually still work.

Continue reading “Apple One, On FPGA” →

Forth Version 1 Runs Again

March 27, 2018 by 23 Comments

Some people love Forth and some people hate it. However, you usually think of Forth as something running on a little computer such as an 8-bit microcomputer. When [Chuck Moore] developed the system back in the 1960s though, it ran on an IBM 1130. [Carl Claunch] took a scanned listing of the original code and got it running once again.

There are actually a few blog posts with details. Luckily, Forth is pretty simple — especially the core parts. However, there are a lot of differences from a modern Forth. The most obvious is that the dot keyword starts a definition and does not print the top of stack. However, internal details are different too — the system, for example, stores characters in packed EBCDIC — an ASCII-like code used by IBM computers.

Continue reading “Forth Version 1 Runs Again” →

Retrocomputing For The Forgotten

February 21, 2018 by 60 Comments

The world runs on marketing hype. Remember the public relations swirl around the Segway? Before it rolled out we were led to believe it was going to be remembered as fire, the wheel, and Segway. Didn’t really happen. Microsoft and IBM had done something similar with OS/2, which you may not even remember as the once heir-apparent to MS-DOS. OS/2 was to be the operating system that would cure all the problems with MS-DOS just as IBM’s new Microchannel Architecture would cure all the problems surrounding the ISA bus (primarily that they couldn’t stop people from cloning it). What happened? OS/2 died a slow agonizing death after the Microsoft/IBM divorce. But for whatever reason [Ryan C. Gordon] decided to write a Linux emulation layer for OS/2 call 2ine (twine).

We like retrocomputing projects even if they aren’t very practical, and this one qualifies. The best analog for 2ine is it is Wine for OS/2, which probably has something to do with the choice of name. You might be ready to click away since you probably don’t have any OS/2 programs you want to run, but wait! The good news is that the post has a lot of technical detail about how Linux and OS/2 programs load and execute. For that reason alone, the post is well worth a read.

Continue reading “Retrocomputing For The Forgotten” →

IBM 1401 Runs FORTRAN II Once More

February 11, 2018 by 41 Comments

The IBM 1401 is undeniably a classic computer. One of IBM’s most “affordable” mainframes, it ruled the small business computing world of the 1960’s. Unfortunately, computers aren’t often thought of as treasured heirlooms, only a handful of these machines survive today. The computer history museum has two machines. One from Germany, and the other recovered from a basement in Connecticut back in 2008. [CuriousMarc] and the rest of the team at the museum have been working diligently to restore the 1401, and they’ve hit quite a milestone — They can now compile and run FORTRAN II code.

Getting the 1401 to run FORTRAN II itself is quite an accomplishment. The hardest part was dealing with the 729 vacuum column tape drives. The team spent years building a hardware emulator which takes the place of the real drives. The emulator is driven by an old PC running windows. Tape images are stored as files, which can be loaded, rewound, and run just like a real 729.

Emulators are great, but [Mark] and his team wanted this to run on the real hardware. They first had to re-create a FORTRAN compiler tape. They ran a tape copier program on the 1401, then loaded an image of the compiler on their emulator. The computer dutifully copied the image to a real tape drive.

The team also needed a punched card deck of FORTRAN source code to compile and run. The first example in the FORTRAN manual is a Hilbert Matrix program. The team could have used a keypunch machine to punch the cards for the program, but that is a painstaking and error-prone process. One mistake, and they would have to re-punch an entire card — much like using an old typewriter with no White-Out or correction ribbon. Instead, they typed the source into a PC, then converted the file to a tape image. A small program instructed the 1401 to punch the source code out on cards for them.

At the moment of truth, shown first in the video, the 1401 reads FORTRAN II from tape, pulls in the source code from punched cards, compiles, runs, and then prints the result on its line printer. All the original hardware singing along just like it did in 1959.

If you haven’t been to the Computer History Museum yet, check it out! It’s also the site of Vintage Computing Festival West.

Continue reading “IBM 1401 Runs FORTRAN II Once More” →

A New Life For A Dead VIC-20

January 26, 2018 by 23 Comments

What was the first computer you bent to your programmatic will? If you’re old enough, it was probably a Commodore. For [Jagged-path], it was a VIC-20. After finding a broken one on Kijiji, he recaptured that 80s feeling with VicPi, a revitalization project that marries modern computing power with vintage form factor.

The VicPi can be used as a standalone computer or a USB keyboard for an external computer. As you’ve probably guessed, there’s a Raspberry Pi involved. There is also a Keyrah board, which is arguably the easiest way to convert Commodore (and Amiga) keystrokes to USB without breaking a sweat.

There are a lot of nice touches that really make this project. A toggle switch on the back selects between VicPi mode and keyboard mode, and the distinction is made with a two-color LED in place of the VIC-20’s power LED. [Jagged-path] used panel mount cables to extend the HDMI, 3.5mm, and USB ports and ran them out to a custom metal panel that’s treated with rubberized black paint. Another nice touch: the dedicated keyboard port is USB-B, so it’s easy to differentiate from the Pi inputs.

If you have a working VIC-20 but not the rare Votrax Type ‘n Talk synthesizer peripheral, you can use an old Android phone to hear those Voodoo Castle responses.

Go Retro To Build A Spectre And Meltdown-Proof X86 Desktop

January 7, 2018 by 95 Comments

[Yeo Kheng Meng] had a question: what is the oldest x86 processor that is still supported by a modern Linux kernel? Furthermore, is it actually possible to use modern software with this processor? It’s a question that surely involves experimentation, staring into the bluescreen abyss of BIOS configurations, and compiling your own kernel. Considering Linux dropped support for the 386 in 2012, the obvious answer is a 486. This supposition was tested, and the results are fantastic. You can, indeed, install a modern Linux on an ancient desktop.

This project got its start last month at a Super Silly Hackathon where [Yeo] and [Hui Jing] installed Damn Small Linux on an ancient IBM PS/1 desktop of 1993 vintage. The hardware consists of an AMD 486 clone running at 133MHz, 64 MB of RAM, a 48x IDE CDROM drive (wow!), a floppy emulator, a Sound Blaster, 10Mbps Ethernet card, and a CompactFlash to IDE adapter. By any account, this is a pimped-out rig for 1993 that would have cost more than a car at the time. The hardware works, but can you run a modern Linux kernel on it?

[Yeo] decided to install the Gentoo x86 minimal installation, but sanity and time constraints meant compiling a kernel on a 486 wasn’t happening. That was done on a modern Thinkpad after partitioning all the drives, verifying all the compilation parameters, and configuring the kernel itself. The bootloader is LILO (Grub2 didn’t work), but for the most part, this is entirely modern software running on a 25-year-old machine. The step-by-step instructions for becoming a /g/entooman on a 486 are available on GitHub.

The entire (boring) boot process can be seen in the video below. One interesting application of this build is that the 486 does not support out-of-order execution, making this completely safe from Meltdown and Spectre attacks. It’s an impressive retrocomputing achievement that right now could not be more timely.

Continue reading “Go Retro To Build A Spectre And Meltdown-Proof X86 Desktop” →