Classic DOS Games On An Arduino?

October 17, 2022 by Al Williams 8 Comments

It has been a while since we’ve seen a 86Duino, but [TheRasteri] reminded us about it, with his video showing how to use one to run classic MS-DOS games. To be fair, the computer isn’t really an Arduino, it’s essentially a tiny 486 PC on an Arduino-style PCB.

If it were just running DOS games on a tiny PC, that wouldn’t be very newsworthy. However, the board by itself has no video card and, as [TheRasteri] points out, sound card compatibility is also a problem. A carrier board, however, has a tiny VGA card on it, and thanks to some work from another user, it is possible to add an ISA bus to the board if you want to plug in a legacy sound card.

The ISA hack was done neatly, but it is a bit of wiring. Instead of using a normal ISA backplane, it is possible to use a PC/104 backplane, if you have cards that will fit that bus — electrically, they are the same. The board was able to run DOOM and Quake at nearly 30 frames per second. Not bad. He did have problems getting a mouse to work, though.

Got a bit nostalgic watching him use QBasic to directly write to registers on an ISA card. If you want an old DOS machine and don’t want to tie up a lot of space, this could be the ticket. Especially if you need it to run some old piece of hardware that won’t work with modern computers. We have to wonder if anyone would make a USB to ISA adapter out of something like this. The drivers would seem to be the hard part.

We saw the 86Duino nearly 10 years ago when there were a few other x86 single-board computers around. Apparently, lots of people want to run vintage games.

Continue reading “Classic DOS Games On An Arduino?” →

Javascript Is Everywhere. Even MSDOS

April 15, 2022 by Al Williams 34 Comments

Although pundits have joked that Java’s “write once, run everywhere” slogan might be better expressed as “write once, debug everywhere,” a relative of Java — JavaScript — has delivered on both promises better than its namesake. Thanks to its proliferation in browsers, JavaScript is a veritable lingua franca of computer languages which has led to entire applications being written in it using tools like Node.js and Electron, and not just browsers. But what if you are still using MSDOS or Windows 98? We know some of you do, at least on retro machines. Don’t feel left out, the DOjS project has jSH, a JavaScript engine for DOS and related operating systems.

Continue reading “Javascript Is Everywhere. Even MSDOS” →

Think Your Laptop Is Anemic? Try An MSDOS One

December 28, 2020 by Al Williams 51 Comments

If someone gifted you a cheap laptop this holiday season, you might be a little put out by the 2GB of RAM and the 400 MHz CPU. However, you might appreciate it more once you look at [Noel’s Retro Lab’s] 4.8 Kg Amstrad PPC512 He shows it off inside and out in the video below.

Unlike a modern laptop, this oldie but goodie has a full keyboard that swings out of the main body. The space below the keyboard contains the LCD screen, which [Noel] is going to have to replace with an LCD from another unit that was in worse shape but had a good-looking screen. In this video, he gets as far as getting video output to an external monitor, but neither LCD shows any sign of life. But he’s planning more videos soon.

Continue reading “Think Your Laptop Is Anemic? Try An MSDOS One” →

Bootstrapping An MSDOS Assembler With Batch Files

December 10, 2018 by Al Williams 26 Comments

You have a clean MSDOS system, and you need to write some software for it. What do you do? You could use debug, of course. But there are no labels so while you can get machine code from mnemonics, you’ll still need to figure out the addresses on your own. That wasn’t good enough for [mniip], who created an assembler using mostly batch files. There are a few .COM files and it looks as if the first time you use debug to create those, but there’s also source you can assemble on subsequent builds with the assembler.

Why? We aren’t entirely sure. But it is definitely a hack. The technique sort of reminded us of our own universal cross assembler — sort of.

Continue reading “Bootstrapping An MSDOS Assembler With Batch Files” →

Microsoft Releases Crown Jewels — From 1982!

October 1, 2018 by Al Williams 45 Comments

If you look back 30 or so years ago, it wasn’t clear what was going to happen with personal computers. One thing most people would have bet on, though, was that CP/M — the operating system from Digital Research — would keep growing and power whatever new machines were available. Except it didn’t. MS-DOS took over the word and led — eventually — to the huge number of Windows computers we know today. Microsoft has released the source code to MS-DOS 1.25 and 2.0 on GitHub.

Microsoft — then another fledgling computer company — had written some BASIC interpreters and wanted in on the operating system space. They paid the princely sum of $75,000 to Seattle Computer Products for something called QDOS written by [Tim Paterson]. Rebranded as MS-DOS, the first version appeared in late 1981 and version 1.25 was out about a year later.

While you might not think having MS-DOS source code is a big deal, there’s still a lot of life left in DOS and it is also interesting from an educational and historical perspective. If you don’t want to read x86 assembly language, there’s also the BASIC source for the samples (paradoxically, in the bin subdirectory) along with compiled COM files for old friends like EDLIN and DEBUG.

Continue reading “Microsoft Releases Crown Jewels — From 1982!” →

MSDOS Development With GCC

May 14, 2018 by Al Williams 19 Comments

It might seem odd to think about programming in MSDOS in 2018. But if you are vintage computer enthusiast or have to support some old piece of equipment with an MSDOS single board computer, it could be just the thing. The problem is, where do you get a working compiler that doesn’t have to run on the ancient DOS machine? Turns out, gcc can do the trick. [RenéRebe] offers a video demo based on a blog post by [Chris Wellons]. You can see the video, below.

The technique generates COM files, not EXE files, so there are some limitations, such as a 64K file size. The compiler also won’t generate code for any CPU lower than a 80386, so if you have a real 8086, 80186, or 80286 CPU, you are out of luck. The resulting code will run in a real DOS environment on a ‘386 or higher or in a simulator like DOSBox.

You might be thinking why not use the DJGPP port of gcc to DOS. That sounds good, but it actually doesn’t produce true DOS code. It produces code for a DOS extender. In addition, [Chris] had trouble getting it to work with a modern setup.

The only real trick here is using the right combination of gcc flags to create a standalone image with the right codes. A COM file is just a dump of memory, so you don’t need a fancy header or anything. You also, of course, won’t have any library support, so you’ll have to write everything including functions to, say, print on the screen. Of course, you can borrow [Chris’] if you like.

The last pieces of the puzzle include adding a small stub to set up and call main and getting the linker to output a minimal file. Once you have that, you are ready to program like it is 1993. Don’t miss part 2, which covers interrupts.

If you pine away for QuickBasic instead of C, go download this. If you just want to run some old DOS games, that’s as close as your browser.

Continue reading “MSDOS Development With GCC” →

QuickBASIC Lives On With QB64

February 22, 2018 by Tom Nardi 188 Comments

When I got my first computer, a second hand 386 running MS-DOS 6.22, I didn’t have an Internet connection. But I did have QuickBASIC installed and a stack of programming magazines the local library was throwing out, so I had plenty to keep myself busy. At the time, I thought QuickBASIC was more or less indistinguishable from magic. I could write simple code and compile it into an .exe, put it on a floppy, and give it to somebody else to run on their own machine. It seemed too good to be true, how could this technology possibly be improved upon?

Of course, that was many years ago, and things are very different now. The programming languages du jour are worlds more capable than the plodding BASIC variants of the 80’s and 90’s. But still, when I found a floppy full of programs I wrote decades ago, I couldn’t help but wonder about getting them running again. With something like DOSBox I reasoned I should be able to install the QuickBASIC IDE and run them like I was back on my trusty 386.

Unfortunately, that was not to be. Maybe I’m just not well versed enough in DOSBox, but I couldn’t get the IDE to actually run any of the source code I pulled off the floppy. This was disappointing, but then it occured to me that modern BASIC interpreters are probably being developed in some corner of the Internet, and perhaps I could find a way to run my nearly 30 year old code without having to rely on 30 year old software to do it. Continue reading “QuickBASIC Lives On With QB64” →