A Mysterious 6502 Apple 2 Simulator

November 11, 2023 by Julian Scheffers 14 Comments

Nice, visual simulators of CPUs such as the 6502 are usually made much later and with more modern tooling than what they simulate. But what if that wasn’t the case? What if a simulator runs on the very hardware it’s simulating?

This is what [Tea Leaves] stumbled upon when he found a mysterious disk with only “APL6502.SIM” on it. [Tea Leaves] demonstrates the simulator with a basic 6502 assembly program, revealing an animated, beautiful Apple 2 simulator that actually runs on the Apple 2! The simulator shows all the major components of a 6502 and actually animates the complete data flow of an instruction.

But why is this mysterious? It’s mysterious because – a “hello” program aside – it’s the only thing on the disk! Not so much as a single clue as to where it came from. [Tea Leaves] finds out where it comes from, including incorrectly copied disk images and a revelation at the end.

Video after the break.
Continue reading “A Mysterious 6502 Apple 2 Simulator” →

A Turing-Complete CPU In Sunvox? Why Not!

August 17, 2023 by Dave Rowntree 7 Comments

Day-time software engineer and part-time musician, [Logickin,] knows a thing or two about programming the SunVox modular synthesiser and tracker software. Whilst the software is normally used for creating music and sound effects, they decided to really push it, and create the VOXCOM-1610, a functional turing-complete CPU inside SunVox, just for fun.

For those who haven’t come across SunVox before now, this software is a highly programmable visual environment for building up custom synthesisers, piecing signals together to create rhythms — that’s the ‘tracker’ bit — as well as interfacing to input devices such as MIDI and many others. It does look like a lot of fun, but just like CPUs created in Minecraft, just because, this seems to be the first time someone has built one inside this particular music app. The VOXCOM 1610 is a fully functional 10 Hz, 16-bit computer. It boasts 2KB of ROM, 256 bytes of RAM (expandable to 128 KB), and 8 general registers for data exchange between components. If you don’t fancy manually poking bits into the ROM to enter your software, then you’re in luck as [Logickin] has provided an assembler (in Java) that should ease the process a lot. The ABI will look very familiar to anyone who’s ever touched assembler before, although as you’d expect, it is quite light on addressing modes.

Now, all that is needed is for someone to port Doom to this and we’ll have it all. We think that is unlikely to happen. For those who pay attention, we did see one neat SunVox project in the past, which is certainly eye-catching as well as eardrum-bursting.

Thanks to [elbien] for the tip!

DOOM On IPhone OS, On Android

July 24, 2023 by Elliot Williams 7 Comments

So you want to play some games from the early days of 32-bit iPhone OS that no longer run on recent OS versions? [Hikari-no-yume] wrote a sweet high-level emulator, touchHLE, to do so on modern iOS phones. But maybe you don’t have an iPhone? [Ciciplusplus] has your back. He ported the iPhone OS emulator, written in Rust, to Android, and then ported a version of DOOM that runs on iPhone OS to go with it.

[Ciciplusplus] also made a video (embedded below) where he documented the trials and tribulations of porting Rust code to the Android platform – an intensely Java environment. It doesn’t sound like it was at all trivial. Of course, this couldn’t have been accomplished without [Hikari-no-yume]’s original work on touchHLE, which was made essentially to fulfill [Hikari-no-yume]’s long-time obsession with the game Super Monkey Ball.

So for now, touchHLE can boast the ability to run a few old 32-bit games on Android and desktop operating systems. What other games from the first years of gaming on smart phones (and iPods) do you need to see ported? Get involved in the project if you’ve got an itch you need scratched.

Continue reading “DOOM On IPhone OS, On Android” →

Minecraft In Minecraft On The CHUNGUS II

May 27, 2023 by Elliot Williams 16 Comments

Minecraft is a simple video game. Well, it’s a simple video game that also has within it the ability to create all of the logic components that you’d need to build a computer. And building CPUs in Minecraft is by now a long-standing tradition.

Enter CHUNGUS II. The Computational Humongous Unconventional Number and Graphics Unit by [Sammyuri] is the biggest and baddest Minecraft computer that we’ve ever seen. So big, in fact, that it was finally reasonable to think about porting a stripped-down version of Minecraft to the computer itself. Yes, that’s right, Minecraft running in Minecraft. (Video embedded below.) Writing the compiler and programming the game brought two more hackers to the party, [Uwerta] and [StackDoubleFlow], and quite honestly, we’re amazed that a team as small as three people pulled this off.

Anyway, once you’ve picked your jaw up off the floor, also check out [Sammyuri]’s video on just the CHUNGUS II computer itself. (Also embedded below.) Seeing the architecture is interesting, even if you don’t speak Redstone as fluently as our heroes here. We love that the assembler creates a block of ROM – out of Minecraft blocks – that you can then cut/paste into the game’s reality.

For a “simple” game about breaking blocks and punching trees, Minecraft has inspired hackers to make the game better both inside and outside of the real world. For instance, for the latest in performant open-source Minecraft servers, check out Folia. Maybe, one day, they’ll build CHUNGUS II in the real world. It could happen.

Thanks [dbcdr] for the tip!

Continue reading “Minecraft In Minecraft On The CHUNGUS II” →

PC Classics, Right In Your Browser With EmuOS

May 6, 2023 by Donald Papp 12 Comments

[Emupedia]’s work to preserve computer history by way of making classic and abandoned games and software as accessible as possible is being done in a handy way: right in your browser with EmuOS.

A few moments of BIOS startup kicks off EmuOS right in a browser window.

Doing things this way has powerful “Just Works” energy. Visit that link in a modern browser and in no time at all you’ll be looking at a Windows 95 (or Windows 98, or Windows ME) desktop, filled with a ton of shortcuts to pre-installed and ready-to-run classic software. Heck, you can even keep it simple and be playing the original Microsoft Solitaire in no time flat. There is also a whole ton of DOS software waiting to be fired up, just double-click the DOSBox icon, and browse a huge list. The project is still in development, so not everything works, but the stuff that does is awfully slick.

Here’s some additional background that goes into more detail about the project and its capabilities, but if you’d prefer to just click around to explore, here’s the main link again (and here’s a list of mirrors.)

If OS emulation is your thing, don’t miss emulating the IBM PC on an ESP32 microcontroller. And if you’re more into lesser-known vintage operating systems, how about re-inventing PalmOS to run on x86 architecture?

Run Linux By Emulating RISC-V On A RISC-V Microcontroller

April 23, 2023 by Jenny List 7 Comments

For years it was a given that it was impossible to run a Linux based operating system on a less powerful computer whose architecture lacked a memory management unit. There were projects such as uCLinux which sought to provide some tidbits to low computing power Linux users, but ultimately they came to naught. It is achievable after a fashion though, by using the limited architecture to emulate a more powerful one. It’s been done on AVR chips emulating ARM, on ARM chips, and now someone’s done it on an ESP32-C3 microcontroller, a RISC-V part running a RISC-V emulator. What’s going on?

RISC-V is an architecture specification that can be implemented at many levels from a simple microcontroller or even a pile of 74 logic to a full-fat application processor. The ESP32-C3 lies towards the less complicated end of this curve, though that’s not the whole reason for the emulation. The PSRAM storage is used by the C3 as data storage and can’t be used to run software, so to access all that memory capacity an emulator is required that in turn can use the PSRAM as its program memory. It’s a necessary trick for Espressif’s implementation of the architecture.

Surprisingly it’s not as slow as might be expected, with a boot-up time under two minutes. It’s not what we’d expect from our desktop powerhouses, but it’s not so long ago that certain lower-power full-fat processors could be just as lethargic. For past glories, see the AVR running Linux, and the RP2040.

NABU PC Gets CPU Upgrade, Emulates A TRS-80

January 1, 2023 by Robin Kearey 11 Comments

The NABU PC caused a bit of a buzz in the retrocomputing community a couple weeks back. After all, it doesn’t happen often that a huge batch of brand-new computers from the 1980s suddenly becomes available on eBay. Out of the box, the computer itself isn’t that useful: with no internal storage, or any application software whatsoever, it can really only serve as a bare-bones development platform. But since its hardware is quite similar to that of other contemporary home computers, emulating one of those shouldn’t be too difficult, which is exactly what [Ted Fried] did: he managed to turn his NABU into a TRS-80 clone by using his MCLZ8 CPU emulator.

The MCLZ8 is basically an 800 MHz Teensy CPU with an adapter board that allows it to be plugged into a Z80 socket. It emulates the Z80 CPU in real-time, but it also holds the TRS-80 ROM and performs real-time translation between peripherals. On the input side, it reads out the ASCII characters coming in from the NABU’s 8251A UART and stores them in the virtual TRS-80’s keyboard buffer. On the output side, it transfers the TRS-80’s video data to the NABU’s TMS9918 video chip.

One problem [Ted] ran into was a difference in screen resolution: the NABU has a 40×24 character display, while the TRS-80 generates a 64×16 character image. [Ted] solved the vertical difference by simply keeping the NABU logo on the screen at all times, and decided to just ignore the 24 characters that drop off the right side – it’s not a big issue for a typical BASIC program anyway.

The repurposed NABU might not be a perfect TRS-80 clone, but that’s not the point: it shows how easily the NABU’s hardware can be reprogrammed to do other things. For example, [Ted] has already started work on a new project that doesn’t emulate the Z80, but instead runs code directly on the Teensy’s ARM A9 processor. As you might imagine, this gives the NABU several orders of magnitude more processing power, although the practical use of this is limited because the CPU still has to wait for the NABU’s slow data bus and display chip. [Ted] explains the setup and runs a few impressive demos in the video embedded below.

[Ted]’s NABU experiments are a great example of the Teensy board’s flexibility: we’ve already seen how it can emulate a Z80 as well as an 8088. We’re also curious to see what others will develop with the NABU’s hardware — if they can still buy it, of course.

Continue reading “NABU PC Gets CPU Upgrade, Emulates A TRS-80” →