emulator

193 Articles

This Circuit Sculpture Is An ESP32-Powered Console

September 11, 2026 by 10 Comments

Expressif might not have intended the ESP32-S3 to become an emulation powerhouse, but that’s certainly what has happened. The little microcontroller seems perfect for recreating the Game Boys or Game Gears of years past, and there are a lot of software options to that end. Having grabbed firmware off a github repo, you still need a physical build to hold, and that’s where this one by [HVT Lab and Huy Vector] stands out.

As you can see, they’re letting everything hang out — not even in a 90s-inspired clear case, but with an open frame of soldered brass, with just a small strip of 2 mm clear acrylic to help stabilize the buttons. That appears to be held with cyanoacrylate glue, but it’s brass and solder doing the majority of the structural work here. We might be a little more confident tossing this lovely device in a bag or pocket if the whole device was boxed in with that acrylic — shorting the exposed power bus on your keys sounds like a bummer — but we can’t argue with the aesthetic vision here. It’s a lovely build on the physical end.

From the video it looks like the software is based on Retro-Go, which we’ve seen in use before. In any case, there are plenty of open source projects you could load onto the ESP32-S3 powering this circuit sculpture, though, from NES to IBM PC.

Continue reading “This Circuit Sculpture Is An ESP32-Powered Console” →

Sail Virtually Aboard The “Itanic” With IA-64 Emulator

July 20, 2026 by 16 Comments

Intel’s Itanium architecture was an interesting experiment, but it has gone down in history as one of the chip giant’s bigger flops, so much so that it earned the name “Itanic” in the tech press. This is perhaps unfair, considering it did limp on until a quiet EOL in 2020. We didn’t know anyone missed it, but perhaps it was more the technical challenge than nostalgia for obsolete server hardware that led [Yufeng Gao] and [gdwnldsKSC] to spin up an instruction-set translator for the late, lamented, IA-64 architecture.

Note that it’s very much in alpha, version 0.1, so don’t expect all the things. Neither HP-UX and OpenVMS will boot, which is a pity since Itanium’s great success was arguably winning those OSes and thereby killing the bespoke architectures HP and DEC had at the time. Gentoo can get to a shell, as long as you use Kernel 6.6 or older, and Windows Server 2003 and XP-64 both apparently boot.

It’s not incredibly performant, with 486-level speeds when running on Ryzen 5000 series hardware, but then, it is a 64-bit hardware being emulated here, and pretty weird hardware at that. Itanium’s Very Long Word Instruction architecture was notoriously hard to program well. Specifically, it was hard to compile optimized programs for, so we expect optimizing an emulator is going to be similarly difficult. That’s why this is so impressive, even at this early stage.

The late, unlamented Itanium is probably one of the few systems not in the Virtual OS Museum, but perhaps eventually this project will change that.

via Raymii.org

DOOM Runs (slowly) In A IBM PC-Compatible CSS Sheet

July 15, 2026 by 10 Comments

Just when you thought we’d run out of things to port DOOM to, here comes [Ahmed Amer] with his CSS-DOS, a massive 300 MB CSS style sheet, that runs not just DOS, but Windows 1.0 and, of course, DOOM. The CSS sheet isn’t holding a DOOM port this time, though — it’s holding a full IBM PC compatible, with a simulated 8086, 640 kB of RAM, floppy and VGA controllers. Yes, in one style sheet. We did mention it was 300 MB, right?

CSS is not a very good programming language. It’s got functions and if statements nowadays, but it doesn’t really do programs in the usual sense. That is, lists of instructions that feed one into another. You can’t change a variable without jumping through hoops. The sort of static behavior you get from a CSS sheet actually matches hardware architecture better than software, which was the key insight [Ahmed] had to make the project possible. It’s still not easy, or elegant, or perhaps even sane, as you can find out from the excellent write-up he has describing how he pulled this off. We particularly like the interactive guide to the full mountain of madness that is the .css file.

Now, we admit that “runs DOOM” may be an exaggeration — even if the maddeningly massive CSS sheet ran an IBM-AT full speed, that hardware can’t handle the game at any playable speed. It doesn’t emulate at anything close to full speed, though. Because this is such a gratuitously weird hack, it only runs at two instructions per second. No, not FPS, instructions, as in at the CPU level. Well, it could be worse, at least it’s not clock ticks. Still, if you’re time-dilated enough you can wait the 3 weeks to boot DOS, and the 3 months to load a level, you can play DOOM at 0.0001 FPS.

Look, we didn’t make the rules — they say everything has to try and run DOOM. They don’t say everything has to run it well.

A 6502 All In The Data

April 15, 2026 by 12 Comments

Emulating a 6502 shouldn’t be that hard on a modern computer. Maybe that’s why [lasect] decided to make it a bit harder. The PG_6502 emulator uses PostgreSQL. All the CPU resources are database tables, and all opcodes are stored procedures. Huh.

The database is pretty simple. The pg6502.cpu table has a single row that holds the registers. Then there is a pg6502.mem table that has 64K rows, each representing a byte. There’s also a pg6502.opcode_table that stores information about each instruction. For example, the 0xA9 opcode is an immediate LDA and requires two bytes.

The pg6502.op_lda procedure grabs that information and updates the tables appropriately. In particular, it will load the next byte, increment the program counter, set the accumulator, and update the flags.

Honestly, we’ve wondered why more people don’t use databases instead of the file system for structured data but, for us, this may be a bit much. Still, it is undoubtedly unique, and if you read SQL, you have to admit the logic is quite clear.

We can’t throw stones. We’ve been known to do horrible emulators in spreadsheets, which is arguably an even worse idea. We aren’t the only ones.

A Novelty Clock Makes The Best Tiny Mac Yet

February 16, 2026 by 8 Comments

We’re lucky enough in 2026 to have cheap single-board computers fast enough to emulate machines from the 1990s, touching on the 32-bit era. We’ve seen a few projects as a result, emulating the Apple Macs of the 68000 era, but even with the best 3D printing, they can disappoint when it comes to the case. So when [This Does Not Compute] saw a novelty alarm clock using a very well-modelled mini replica of an early Mac, putting a Mac emulator in it was the obvious way to go.

The project uses a Raspberry Pi with a small colour LCD.  The video below the break takes us through the process of gutting it and mounting the Pi and display on a custom 3D-printed bracket. In an unexpected touch, parts of the original LCD are used to give the curved corners, which owners of an original Mac will remember. It may have a little further to go in that its fake floppy drive is begging to be converted to an SD card slot, and it has a now-unused brightness dial. But we’d say it’s one of the best little Mac emulators we’ve seen so far, if perhaps not the smallest.

Continue reading “A Novelty Clock Makes The Best Tiny Mac Yet” →

PlayStation 3 Emulator RPCS3 Can Play Nearly Three-Quarters Of All PS3 Games

January 22, 2026 by 6 Comments

Although already having entered the territory of ‘retro gaming’, the Sony PlayStation 3 remains a notoriously hard to emulate game console. Much of this is to blame on its unique PowerPC-based Cell processor architecture, which uses a highly parallel approach across its asymmetric multi-core die that is very hard to map to more standard architectures like those in today’s x86 and ARM CPUs. This makes it even more amazing that the RPCS3 emulator team has now crossed the 70% ‘playable’ threshold on their compatibility list.

This doesn’t mean that you can fire up these games on any purported ‘gaming system’, as the system requirements are pretty steep. If you want any kind of enjoyable performance the recommended PC specifications feature an Intel 10th generation 6-core CPU, 16 GB of dual-channel RAM and a NVIDIA RTX 2000 or AMD RX 5000 series GPU or better.

It should be noted here also that the ‘playable’ tag in the compatibility list means that the game can be completed without game breaking glitches. Performance remains an issue, with very creative optimizations through e.g. the abuse of x86 SIMD instructions remaining the topic of research by the emulator developers. Yet as original PS3 hardware gradually becomes less available, the importance of projects like RPCS3 will become more clear.

Header: Evan-Amos, Public domain.

EmuDevz Is Literally A Software Game

October 16, 2025 by 11 Comments

The idea of gamifying all the things might have died down now that the current hype is shoving AI into all the things — but you’ve probably never seen it quite like EmuDevz, a game in which you develop an 8-bit emulator by [Rodrigo Alfonso].

There’s a lot of learning you’ll have to do along the way, about programming and how retro systems work, including diving into 6502 assembly code. Why 6502? Well, the emulator you’re working on (it’s partially-written at the start of the game; you need only debug and finish the job) is for a fantasy system called the NEEES “an antique game console released in 1983”. It’s the NEEES and not NES for two reasons. One, Nintendo has lawyers and they really, really know how to use them. Two, by creating a fantasy console that is not-quite-a-Famicom, the goalposts for EmuDevz can be moved a bit closer in.

Continue reading “EmuDevz Is Literally A Software Game” →