Retro Games Limited (RGL) has announced that the release of TheA1200 computer has been delayed by almost six months. The Commodore Amiga-emulating full-size A1200-like design has been up for pre-order since Nov 2025, and retro-hungry fans were anticipating deliveries of the first units on June 16, 2026. In a social media post on Wednesday, RGL announced that the machine won’t be available until December 4, 2026. It blamed a combination of “global chip shortages and rising plastic production costs” for the setback. However, the firm insists that TheA1200 specs and pricing will not be adjusted.

In some ways, we are surprised that the release plans for TheA1200 have been impacted by the global chip crunch. An original Amiga 1200 had such puny specs compared to systems nowadays – it used a 14 MHz processor, 2MB (not GB) of RAM, and zero fixed storage, just a floppy disk drive. We would assume RGL is going to create TheA1200 using the magic of emulation and a cheap Allwinner/Rockchip Arm SoC backed by 512MB to 1MB of RAM. However, the tendrils of the AI boom are now beginning to spread and strangle tech production beyond the high-end RAM, NAND, and processor niches.

RGL also notes that TheA1200 OS “isn’t yet where it needs to be.” This aspect of the product is currently functional, it is explained, but for the best possible Amiga experience, the dev team needs more time “to get it right.”

Obviously, delays like this are frustrating to folks who have already endured a protracted pre-order period. An extra (almost) six months of patience is quite a lot to ask. With this in mind, RGL has prepared an FAQ regarding the delays. We’ve embedded the full blurb above, but key takeaways are that pre-orders will stand unless you are fed up enough to cancel, the price isn’t going to change, and the machine specs will not be adjusted. Furthermore, TheA1200 is “fully on track for release on 4^th December 2026,” insists RGL.

We visited the U.S. distributor’s TheA1200 product page on Amazon.com and saw that the machine is still up for pre-order at $189.99 at the time of writing. However, the release date hasn’t yet been updated; it still says “June 16, 2026” is when TheA1200 will become available.

TheA1200’s price looks quite competitive for a bit of retro fun in 2026, with the entry price of even basic computers and SBCs ratcheting up lately. The pre-order value looks even better compared to RGL’s TheA500 Mini, which is listed at $218.95. This well-reviewed Mini Amiga can also play A1200 games, but it doesn’t have a functional keyboard, and thus lacks the real Amiga feel and presence.

ZSNES is a legendary Super Nintendo Entertainment System emulator with its roots stretching back to the DOS era. Created by zsKnight and Demo, the last major release of this seminal hand-tuned, assembly-coded emulator was nearly two decades ago. It has been reborn this week as Super ZSNES with “super enhancements” powered by your system’s GPU. Rewritten from scratch by the aforementioned dynamic duo, Super ZSNES now boasts “far more accurate CPU and audio cores than the original ZSNES,” as well as a “GPU-powered PPU core.”

See some hands-on Super ZSNES footage and discussion from MVG, above. The RetroTuber has had access to this emulator reboot for a couple of weeks.

Before deciding to go ahead with this project, zsKnight had pondered what to do differently for a reboot. The dev told MVG, “I had to brainstorm a bit, thinking what I could do differently. So, I started out by writing a GPU renderer that replaces a large chunk of the SNES PPU emulation with rendering done mostly on the GPU through shaders.”

The big underlying challenge here was the SNES architecture being CRT-based and GPUs being geometry-based, but zsKnight enjoyed jumping the hurdles. In the first release of Super ZSNES, MVG confirms tasks such as “palette lookups, tile rendering, transparencies, mode 7, color math, main and subscreen combinations, mosaic effects are all handled via GPU shaders.” This architecture unlocks some ‘Super’ enhancements in the new UI, and some intriguing possibilities for coming releases – like high-res textures, for example.

Another aspect of this new emulator that makes it 'Super' is its new Super Enhancement Engine, and it is here that we reckon the new GPU-powered architecture will also often come into play. We’ve tabulated what this means to your old SNES games, below.

Before we go, we note that the new Super ZSNES was put together using Unity. However, the devs insist that there’s been “no vibe coding” and everything under the hood was completed “classic development style.”

Naturally, as this is version 0.100 of the new emulator, there are bugs to be fixed, improvements to implement, and enhancements to come – such as netplay. There’s also a disclaimer that “This is an early build, so there are still emulation bugs and special chips (DSP1, SuperFX, etc.) have yet to be implemented. A bunch of optimization work has yet to be done so performance may be a bit slow.”

MVG notes that zsKnight has highlighted work-life-ZSNES development balance. While the devs are loving being back in the saddle for this project, and the initial reception to the reboot has been great, more direct support via platforms like Patreon would perhaps help oil the wheels.

You can grab Super ZSNES now for Windows, Mac, Linux, and Android, and there is an iOS release “coming soon.”

PC emulation on Android has come a long way from the days of its inception. Today, we have hardware that can natively run a lot of games through translation layers, all while delivering reasonable frame rates. And there is no better device to show this progress than the Redmagic 11 Pro Golden Saga Edition — the most powerful Android phone in the world, and it can play AAA PC games better than a Steam Deck.

The video above from ETA Prime showcases a bunch of games running inside GameHub, a Windows emulator that translates x86 code into Arm. GameHub actually started as just mapping software for GameSir's controllers, but has since transformed into a full-blown emulator that comes baked into Redmagic devices. It has native integration with Steam, so all your save files are synced on mobile, just like on a PC.

The phone in question is a special edition of the Redmagic 11 Pro that features 24 GB of RAM and upgraded internals for slightly better cooling. The rest of the specs are identical between the regular model and this Golden Saga Edition, such as the Snapdragon 8 Elite Gen 5 chip, the 6.9-inch OLED display, and the 7,500 mAh battery. There's 1 TB of storage onboard, and the phone features liquid cooling, along with a fan.

Coming back to the actual performance, ETA Prime ran Red Dead Redemption 2 at 720p with low settings and no upscaling. The game ran at above 50 FPS even in outdoor areas, and it was locked at 60 indoors, but drops down to the 40s at higher render distances in the open world. This was in the "Rise" performance mode, which is one tier below the maxed-out "Diablo" mode, and the phone was docked while playing.

Enabling the Diablo profile, the frame rate jumped from the low 40s to the low 50s, but the power draw also went up to 40W. We even saw an insane peak of 45W; that's laptop territory, and the YouTuber reiterated it's not thermally sustainable, even with a cooler on the back. Throughout the test, RDR2 consumed around 20 GB of RAM, so the extra memory pool is certainly worth it if you want to run AAA games.

ETA Prime also tested GTA V, and it ran at above 70 FPS, while reaching 100 FPS in indoor scenes. It's crazy to think that just a few years ago, something like this would still be a fake YouTube video, but it's real now. Ghost of Tsushima was also playable at above 40 FPS, while Resident Evil: Requiem actually ran at over 60 FPS, but it was unfortunately marred with glitches like missing walls in sections of the game.

Lastly, Cyberpunk 2077, arguably the benchmark for emulation and porting at this point, was able to deliver a consistent 60+ FPS with frame generation. Without it, the game can run at a locked 30 FPS, which would be a similar experience to the Steam Deck. ETA Prime has also tested Cyberpunk on the regular Redmagic 11 Pro, where it ran at around 50 FPS with frame gen, so the extra RAM here is certainly helping.

So, how much does this magical device that can open the doors to a world of PC games in your hands cost? It's listed for around $1,700, while not even being available to purchase in the States, so you'll have to import it. Before the RAMpocalypse, one could get a Strix Halo handheld for that kind of money, which would be a significantly better, albeit less novel, gaming experience.

Of course, a phone can't be compared to a dedicated gaming device. Redmagic specifically makes these for enthusiasts who don't consider money an object, so there's no value argument here. Besides, it's simply impressive to see something that can also make calls and take photos, play games at such a high fidelity. What's even more exciting is that the PC emulation scene on Android only goes up from here.

A member of the Save Myrient community has announced that the colossal video games archive has been “100% backed up!” This retro-gaming resource was on the precipice of collapsing last month after collection admins revealed that insufficient funding, rising costs, and abusive download managers were taking a heavy toll on the operation. Costs concerns were particularly strong with skyrocketing RAM, SSD, and hard drive prices.

It is great to share good news regarding the preservation of classic video games. Redditor and SaveMyrient mod, Ill-Economist-5285, fanfared the success of backup efforts just ahead of the weekend. “We've been kicking major ass in the background getting downloads completed and validated,” wrote the mod. “We can now announce that the Myrient mirror is now 100% COMPLETE!!”

As for getting the mirror up and operational, remember the original site doesn’t get decommissioned until the end of this month. However, with the 385TB resource now backed up, work is underway “generating torrents and getting them available.”

Torrents? Yes, but another SaveMyrient mod has confirmed “Torrents is only a temporary solution as of now.” With commenters pledging to make sure to seed their file-collections. Meanwhile, Ill-Economist-5285 reassures Myrient fans that things will be back to normal soon, with some resources being taken down temporarily only to make things ready for the next stage of the plan. More news will come, we are teased. Hopefully soon.

As mentioned previously, Myrient is still operational. So I thought I’d take a look. It was good to see some old favorite Atari ST apps like Calamus there. Moreover, if you feel like celebrating the 30^th anniversary of the release of Descent II on MS-DOS (March 13 in the U.S., March 29, 1996 in Europe) then today may be a good day to do it.

Myrient and AI

The AI industry frenzy undoubtedly contributed to the original Myrient archive’s soaring costs, ahead of its closure announcement. Perhaps ironically, if Myrient hadn’t been saved, retro fans may have looked to AI to generate copies of their favorite apps and games of yesteryear?

Unless you're a low-level developer yourself, you probably don't realize how complicated emulator development is. To be frank, the RPCS3 emulator for PlayStation 3 is probably one of the most tightly-optimized pieces of software being actively developed today. Case in point: the project's official X account just posted a screenshot of the app running the PlayStation 3 version of Minecraft and achieving some 1558.84 FPS on the title screen.

There are a lot of "yeah buts" about this result. It's Minecraft, and more than that, it's not even in-game; it's the title screen. The thing you have to understand is that this isn't just "running Minecraft at over 1500 FPS." This is "pretending to be a PS3 that is running Minecraft at over 1500 FPS." That is an entirely different task, and in an entirely other galaxy of complexity.

As a refresher, the PlayStation 3 was released in November 2006. It's a game console that features a graphics processor, the Reality Synthesizer or RSX, that is a very close relation (though not identical to) an NVIDIA GeForce 7800 GTX, albeit with half the memory bandwidth and a few other tweaks. That GPU is mated to the IBM-Sony-Toshiba Cell Broadband Engine, a single-core PowerPC CPU with eight "Synergistic Processing Elements" (SPEs) hanging off the back of it, though only seven are functional in the final design.

So, a single-core CPU with SIMD and an old GPU. Easy to emulate on modern hardware, right? No. The design of the PS3 is legendarily idiosyncratic. The RSX and the Cell communicate with each other over a proprietary bus called FlexIO, which is extremely fast—sometimes. For certain transfers, it can be as slow as 16 megabytes/second. Complicating matters, the latency of a FlexIO operation varies depending on whether you're reading or writing, and which device you're doing either to and from. This matters because software is programmed to expect a certain latency, and screwing it up could crash a program or cause other unexpected behavior.

Moreover, the Cell's SPEs are not like a modern CPU's SIMD units. They're somewhere between that and discrete CPU cores, with their own 256K of "Local Storage" and their own memory controller that works independently of the "SPU", which is the actual functional unit inside the SPE. The SPUs can only work on data resident in their own Local Store, but loading data in and out of the Local Store has to be done manually by the developer by sending commands to the Memory Fabric Controller inside each of the six usable SPEs (one is reserved for OS functions).

Worse than that, the SPUs are spectacularly weird processors. They can only work with just a few data types, and they do things that modern processors simply aren't capable of without considerable work shuffling bits around; a single instruction explodes into dozens. In particular, the SPUs perform a lot of 128-bit atomic operations that require tons of complex, tightly-optimized code to emulate both quickly and accurately on x86-64 CPUs, and that's to say nothing of trying to perform said emulation with a "close-enough" latency. Recently-added instructions as part of the AVX-512 ISA extensions help with this, but don't fully resolve it.

All this to say that yes, it's Minecraft's title screen. It's Minecraft's title screen coming out of an application that's emulating all this arcane PlayStation 3 hardware within less than two-thirds of a millisecond (0.64ms). I wasn't kidding when I said RPCS3 is one of the most heavily optimized pieces of software on the planet. The recompiler is doing things normal developers would stare at in befuddlement for speed.

Still, the replies to the Twitter post are largely unappreciative. It's easy to understand how they feel; when a game from 2009 won't run smoothly on your 2026 hardware, it feels ridiculous—although we have to point out that actual 2026 hardware generally will run everything just fine; even God of War III and Metal Gear Solid 4 are mostly playable on the best CPUs for gaming.

The simple reality is that the PS3 was a beautiful disaster of a machine, and the way it does things is just fundamentally different from the way we do things in x86-land. The fact that the app exists at all is a testament to the hard work put in by kd-11, Nekotekina, Whatcookie, and the dozens upon dozens of other contributors to the open-source project. Our very humble hats off to the team for donating countless hours of their free time to push the state of PS3 game preservation ever forward.

Yes, you did read the headline correctly, and you'd be wise to fetch a cross, garlic, and a stake. Lyra Rebane, a madlady who dabbles in CSS and infosec, figured out she could leverage the power of contemporary implementations of the stylesheet language to emulate an x86 processor, all without even a single line of JavaScript, WASM, or any other such tomfoolery.

The emulator even comes complete with a basic display and keypad, and some preinstalled programs for calculating the Fibonacci sequence, Pascal's triangle, and a variation of Wordle. You'll need a recent version of a Chromium-based browser, as some CSS features she used are not yet standard. Rebane even goes as far as showing fellow mad-people how to compile their own C programs for the emulator using the gcc-ia16 compiler.

As the first question out of everyone's mouths will be "Can it run Doom?", the answer is that no, it cannot, or at least not yet. While the x86css emulator implements most of the x86 assembly, it's missing key functionality like interrupt handling, port input/output, and block-operation instructions, all key to making most any game as we know them. Perhaps more poignantly, Doom is a 32-bit program and requires a 32-bit CPU (80386 or above), 4 MB of RAM, and the ability to enter protected mode.

Cold-hearted developers like myself will also find some warmth in the fact that Rebane did not use any vibe-coding or AI bot assistance for writing this emulator. And as she points out, a bot could have hardly done this, as the necessary leaps in logic to force CSS to be a full-fledged state machine require some serious out-of-the-box thinking. Rebane points to Jane Ori's CSS CPU Hack as instrumental to her own ideas.

As to the reason or utility of such an enterprise, she simply stated that it was a fun project. Many developers (me included) have long made jokes when people mention HTML and CSS as "programming languages," and this is definitely a moment of harsh acceptance. Some commenters wonder if this implies that contemporary CSS might become a serious attack vector, but that seems unlikely given that Rebane had to create the machine to run the code with.

PicoIDE launched earlier this week, touted as “an open source IDE/ATAPI drive emulator for vintage computers.” This single 3.5-inch bay fitting device can replace those aging optical drives (and media) and HDDs, that your retro-PC relies on, with the convenience and capacity that modern microSD cards provide. It uses an appropriate retro-design aesthetic (in beige or black). You can back this project for as little as $69 for the base model, will free shipping in the U.S. and an expected June 14 dispatch date.

Polpotronics LLC, the outfit behind the PicoIDE, highlights the increasing issue of “worn out lasers, crashed heads, or bad sectors,” that even the best maintained vintage PCs can be prone to. At the same time like-for-like hardware replacements are getting scarcer, so a modern retro-embracing, transparent, open-source alternative becomes a compelling project.

Two versions of the PicoIDE are being made available, the PicoIDE Base ($69, beige), and the PicoIDE Deluxe ($110, beige or black). Whichever you choose, you get the following features:

• Full 3.5-inch drive bay enclosure (injection molded)
• Standard 40-pin IDE connector
• 4-pin Molex power connector
• Headers for external activity LED and action button
• SPI header for future expansion
• Emulates ATAPI CD-ROM drives and IDE fixed hard drives
• Images stored on microSD card (FAT32 or exFAT)
• CD-ROM formats: .bin/.cue (with audio track support), .iso
• HDD formats: .img, .hda, .vhd (with CHS geometry), .hdf
• LBA and CHS addressing modes for maximum compatibility
• Configurable vendor/model strings for compatibility with picky systems
• Supports PIO modes 0-4 and multi-word DMA modes 0-2
• Powered by Raspberry Pi RP2350
• IDE bus operations accelerated with PIO state machines
• Double-buffered read-ahead for optimal throughput
• Hot-swap image selection when inserting mickroSD
• Configuration via ini file on microSD
• Firmware updates from the micoSD
• High-quality TI PCM5100A DAC for audio out
• MPC-2 header for internal sound card connection
• 3.5 mm line-out jack for external audio

A killer convenience feature of the PicoIDE is its ability to hold multiple drive images, say with different DOS, Windows, OS/2 and other installations, and on-the-fly switch to load your chosen image at next-boot – all from a single micoSD card. Moreover, PicoIDE emulates a multitude of drive geometries.

PicoIDE is also truly open source. That permeates the hardware, firmware, and documentation. With all design and source files promised to be available via GitHub before the device begins shipping. Documentation is already there.

In the intro, we mentioned that you can back this project for as little as $69 for the base model, with free shipping in the U.S., and an expected June 14 dispatch date. But please remember that crowdfunding a project is not a guarantee of receiving a finished product within the timescale highlighted, if at all. Backing a crowdfunded project is more like an investment; you believe in the project and want it to succeed. You are not purchasing a retail product.

A new emulator makes running classic Apple Macintosh 68K software a breeze on a cheap, portable, IoT development kit. Developer amcchord has ported the popular Basilisk II Mac emulator to the ESP32-P4 / M5Stack Tab5 ($60). The device name gives away that this is a small (5-inch) tablet that relies on an ESP32-P4 SoC for horsepower. We’ve seen 68K Mac emulation on microcontrollers before, but as Hackaday points out, this represents a major step forward in performance on one of these tiny SoCs. In brief, its RISC CPU is capable of delivering 68040 Mac-level computing in OS8.1.

This ESP32-P4 / M5Stack Tab5 port of Basilisk II is particularly appealing for Mac emulation tinkerers, as it is quite a well-rounded platform. It is a tablet, and can be used as such in the emulator, with its native touch functionality replacing mouse interactivity. In computer terms, it becomes almost a touch-enabled All-in-One, with your keyboard/mouse of choice attached via USB.

First-decade Apple Macs were also most famously represented by All-in-One designs with tiny screens (9-inch 512x342 pixel mono displays). In comparison, the Tab5’s 2x scaled 640x360 resolution 8-bit color output piped to the 5-inch 1280x720 IPS touchscreen could challenge your near vision.

For processing power, the Basilisk II ESP32 is said to be up to the level of a Motorola 68040 with FPU (68881). That would be like a mid-90s professional Macintosh. This implementation is limited to a maximum of 16MB of memory, though, using half of the ESP32-P4 / M5Stack Tab5’s 32MB. That should be enough for tinkering in MacOS versions all the way up to version 8.1, but the refresh speeds will be limited to 15fps, which is fine for productivity but might irk in classic game titles.

The ESP32 here has a dual-core RISC-V architecture running at 400 MHz, and the emulator uses one core for video and I/O, with the other for the 68040 interpreter, and other low-level system function patching.

For storage, users of this IoT tab can make use of HDD and CD images that are saved on an SD card. In addition to the OS and apps you have, this is where you will put your Mac boot ROM files.

Overall, it is a very neat and portable all-in-one emulation solution. It would also be a great starting platform for modding, as you could make a mini Mac Classic with this and a 3D printer without jumping through too many hoops.

68K Mac emulation in a browser

If the above tale of cute portable classic Macintoshes has stirred something deep inside, you can very easily and quickly enjoy a quick 68K Mac fix through your browser.

A couple of years ago, we shared a guide on How to emulate an original Apple Macintosh in your browser. Check that out, and we will talk you through visiting Infinite Mac. We also discuss various Infinite Mac configuration options for those who want to have more than a fleeting encounter with a vintage Mac OS and software.

Vintage game emulation just got another slight boost, thanks to the release of D7VK version 1.1. This Direct3D-to-Vulkan translation layer makes it possible to run old Direct3D 7 games on contemporary hardware, and it got some meaty improvements, including a new front-end, and experimental support for Direct3D 6.

In case you're a little confused, D7VK is a translation layer that turns Direct3D 7 calls to Direct X 9 running under Proton's DXVK layer, thereby taking advantage of DXVK's tried-and-true infrastructure and software ecosystem. Being a mere translation layer, it has a minor performance penalty and can run several times faster than a full emulator like WineD3D.

Alongside with a new front-end, the 1.1 update adds Direct3D 6 support as an experimental option. The author mentions that judging by its documentation, adding this API shouldn't be a lot of work. That's in sharp contrast to the lawless lands of Direct3D version 5 and under. Even as it stands, in their own words, "D3D7 is a land of highly cursed interoperability", with many games mixing Direct3D calls with older Windows APIs like DirectDraw and even GDI for 2D graphics.

In turn, this means that support for games is hit-or-miss, depending on how "hacky" the game was initially programmed. For example, this latest version adds a workaround specific to Sacrifice, which uses a wholly unspported depth buffer format. Likewise, support for strided primitive rendering makes Sacred playable, and fixes to mipmap swapping enable gamers to once again enjoy Gothic, Gothic 2, and Star Trek DS9: The Fallen as if they were just released.

Many popular Direct3D 6 titles have seen re-releases using modern APIs, including Final Fantasy VIII, Resident Evil 2, and Grand Theft Auto 2.

Additional fixes for games include workarounds for Conquest: Frontier Wars, Tomb Raider Chronicles, Darkan: Order of the Flame, Earth 2150, Tachyon: The Fringe, and Arabian Nights. If you have a particular game that doesn't run well, visit the issues section in the D7VK GitHub to lend your feedback. In the meantime, if your game doesn't run or is too old to use even Direct3D 7, you can use Wine's WineD3D instead.

WinD3D ironically also works in Windows itself, making older games easy to run on contemporary versions of the OS. If your vintage title used old Glide or OpenGL instead, the author recomments nGlide.

Jace from self-confessed “silly tech” YouTube channel MetraByte has shared a video documenting their attempts to get Windows 95 and Doom up and running on the Sony PlayStation 2. In brief, Windows 95 eventually yielded to attempts to get it to boot, and it was possible to fiddle around in the standard apps, but there was no way Jace could get Doom to launch.

Both these platforms are very long in the tooth in 2025, of course. Windows 95 arrived in 1995, and the PS2 debuted in the year 2000. With its half-decade tech-age advantage, you might expect the PS2 to sail through the Windows 95 and Doom challenge. Indeed, it might have, but the hacky nature of getting x86 code to run on Sony's MIPS machine, plus the well-known foibles of Windows 95, built on DOS, meant there were lots of hurdles.

So, how did Jace do/not do it? It is quite a long story, but Jace condensed tens of hours of coaxing the PS2 to run Windows 95 into less than half an hour (video embedded above).

All Jace’s testing took place using a modded PlayStation 2, a game controller with a QWERTY keypad, plus a USB stick and a hard drive inserted into the fat PS2 for storage and data transfer. In parts of the video you can see Jace use a specially prepared USB stick or HDD which packed in the following contents:

• A PlayStation .ELF file. This is the homebrew code to run on the modded PS2. DOSBox and Bochs emulators for the PS2 were both tried.
• A virtual DOS boot disk or image file
• A Windows 95 install HDD or .ISO image file
• A free partition or image file for installing Windows 95 and Doom

Jace's initial time-consuming effort to use DOSBox to achieve their Windows 95 and Doom goals stalled, and after at least “47 attempts” to persuade the vintage OS to boot to desktop, our mad scientist decided to switch to another emulator called Bochs. The former is designed primarily for enjoying simple games, where the latter is billed as an accurate (and slower) general-purpose x86 emulator.

If you watch the full video, you will almost feel Jace’s pain. Such is the slow and frustrating process of getting an x86 OS onto this MIPS console. Nearly every process took an ungodly amount of time, hampered by limited and slow I/O on the PS2, the emulation layer, and these early editions of Windows sitting precariously upon DOS.

Using Bochs wasn’t plain sailing, either. Jace had to deal with a wide range of system hurdles, complaints about read errors, write errors, boot order, drive letter and mounting configurations, missing files, drivers, and more. However, they eventually saw the Windows 95 setup screen appear on their PS2 screen.

Developer NSG650 has succeeded in his attempt to get “Linux running in Excel.” The GitHub-hosted and aptly named LinuxInExcel project was uploaded to the cloud-based developer platform earlier this week, and updated with input support just yesterday.

Getting Linux to run within the confines of Excel is the latest in a long line of Excel coding gymnastics, which might only be rivaled by those boasting of running various incongruous software gems inside PDFs. And yes, we have already seen Linux running inside a PDF.

If you’ve read about these kinds of software feats previously, you'll know there is perhaps more than an ounce of trickery in running complex software like Linux within the confines of a spreadsheet application.

Developer NSG650 openly admits that his achievement leans heavily on a RISC-V emulator built by fellow GitHubber cnlohr. It also makes use of a Microsoft VBA macro to call the emulator in the DLL, which “gets the output and writes it into the cells in the spreadsheet.”

Using this emulation layer and software vector to run Linux takes a toll on performance – and stability doesn’t seem to be the best, either. NSG650 confirms LinuxInExcel is “very buggy,” but seems to be happy enough with achieving the software milestone, as it stands. It was “done mostly for fun,” says the Bangaluru-based developer in the GitHub readme.

Despite exhibiting little intention to refine his LinuxInExcel project, it has already seen an important improvement. Specifically, NSG650 thanks YouTuber Enderman (who hit our headlines in 2023 by tricking ChatGPT into generating Windows 95 keys) added interactivity by implementing input support.

Almost a full sixteen years following its initial November 2008 release, Sonic Unleashed finally has a fully-blown native PC port, dubbed Unleashed Recompiled. This is a Recompiled PC port, specifically, thanks to fan efforts pioneering the XenonRecomp and XenosRecomp tools used to do it, allowing for PowerPC code and Xenos shaders to be converted into x86 PC-compatible C++ and HLSL code, respectively.

This also means that, in theory, any Xbox 360 game should now be fully Recompilable for native PC port goodness, including those unsupported by modern Xbox Backward Compatibility, effectively freeing several games from the graveyard — and opening the doors of modding wider than ever. If this sounds familiar to you, it might be because a similar endeavor gave us Zelda 64: Recompiled and N64: Recompiled, which we've covered previously.

Locking in on Sonic Unleashed specifically, one may be left wondering what exactly pushed fans so far as to make a native PC port before Sega did. In truth, Sonic Unleashed has long been something of a white whale for the Sonic modding community on PC — the Unleashed Project and several related mods have long existed to port most of the game's highlight content (Daytime stages, which inspired all future Boost formula gameplay) into the original PC port of Sonic Generations. Until Xbox Series S/X Backwards Compatibility and FPS Boost capabilities were added, modding Generations PC was the only way to play these levels at a silky-smooth 60 FPS, since the original PS360 hardware could often dip below 30 FPS trying to run Unleashed's massive levels flush with graphical flourishes like full Global Illumination (though pre-baked rather than today's modern RTGI).

In more recent years, progress on Xbox 360 and PlayStation 3 emulation through Xenia and RPCS3 has also progressed significantly, providing a venue through which players could play the full game on PC, albeit with a performance loss compared to Generations modding thanks to emulation overhead.

But finally, fans of Sonic Unleashed can enjoy the game in a form truly unleashed for modern platforms thanks to Unleashed Recompiled, which uses recompilation tools built on top of Xenia's emulation progress, now refined fully into a much easier-to-run PC port. The PC port adds all the staple features one would expect, including uncapped resolution support and proper graphics settings. There are even some nifty extras, like a "Music Attenuation" feature that automatically mutes in-game music whenever you're playing audio off a music player. You can also raise the FPS cap above 60 FPS, but due to the physics issues introduced by doing this, I highly recommend employing the use of Lossless Scaling or your GPU's own universal Frame Generation solution to play above 60 FPS, instead.

Of course, those hoping to play with Unleashed Recompiled or wanting to make their own Xbox 360 recompilations will need to legally secure their own copies of the Xbox 360 titles, DLC, etc, as with any emulation-adjacent project. But compared to having to play these games on consoles — particularly considering the fact that Unleashed Recompiled even supports fully-blown graphics and gameplay mods like Foreign Input System and Improved Progression via the HedgeModManager — the best choice for playing Xbox 360 games is now more obvious than ever.

Welcome to PC, Sonic Unleashed — we've been waiting for you.

A version of the Linux operating system can now be run inside a PDF opened by a Chromium-based browser. The brains behind the coding gymnastics involved in this 6MB LinuxPDF project belong to high school student Ading2210. If the name is familiar, it might be because the same person created DoomPDF, which we reported on in January.

Ading2210 explains that Linux runs in the PDF within a modified version of the TinyEMU RISC-V emulator. The developer notes that LinuxPDF "works in a very similar way to my previous DoomPDF project." Like DoomPDF, this Linux-in-a-doc project also has a bit of a performance problem, as it is claimed to be "over 100x slower" than it should be.

The TinyEMU RISC-V emulator runs in the PDF thanks to a technique where its code is compiled "using an old version of Emscripten that targets asm.js instead of WebAssembly." This is embedded and loads in the PDF, subsequently auto-running a minimal Linux kernel targeting that architecture. In this implementation, once you agree to 'Start Emulator' in your browser, you will see the LinuxPDF UI load, and a welcome message in the Linux viewport, as you wait for the OS to boot.

Those who dabbled with the DoomPDF release will see some familiarity with LinuxPDF's low-contrast gray display. LinuxPDF also outputs to the screen via the same line-by-line ASCII output that drove the gaming PDF.

Below the Linux viewport in the PDF is a soft keyboard created by an array of PDF buttons. However, it is likely quicker for everyone with a decent physical keyboard to input commands into the 'type here for keyboard inputs' field to the lower right of the keyboard UI area.

On the topic of speed and efficiency, Ading2210 humbly admits that performance might be the largest problem with LinuxPDF. "The Linux kernel takes about 30-60 seconds to boot up within the PDF, which [is] over 100x slower than normal," notes the developer. With Chrome's current PDF engine having its Just-in-Time (JIT) compiler disabled, Ading2210 sees no way of speeding up the code, for now.

If you wish to try out the LinuxPDF, it requires a Chromium-based browser to work correctly (we checked, but it didn't work in Firefox on PC). Others might be satisfied to simply watch Ading2210's video of LinuxPDF starting, booting, and responding to a handful of commands. As with Ading2210's previous projects, the source code is all available to read and tinker with on GitHub.

This week, developers behind the PlayStation 3 emulator RPCS3 announced that RPCS3 had now achieved stable, native Arm64 architecture support for Windows, macOS, and Linux platforms— Arm64 architecture support so definitive that it even includes the Raspberry Pi 5, of all devices, utterly pushing the limits of emulation believed possible on the Raspberry Pi 5. In the past, Raspberry Pi 5 has also been seen emulating GameCube and Wii (Wii less effectively) — but with the correct settings adjustments, it seems even PS3 emulation is possible on today's entry-level Arm hardware.

Running PS3 emulation on Raspberry Pi 5 is very much "challenging the limits of PlayStation 3 emulation"— considering the settings used, which make the affair look like a genuine PlayStation Portable (PSP) game by scaling down to the PSP's output resolution of just 273p versus PS3's native 720p. But this makes running some 3D games actually possible, including God of War (and God of War II) HD (originally PS2 games), Catherine, Naruto: Ultimate Ninja Storm, and more. 2D games will be a lot more playable across the board, of course, but even being able to turn around playable framerates in PS3-era 3D titles is well beyond the emulation capabilities most would expect from a Raspberry Pi 5.

Over on the MacOS side of things, native support for Arm architecture versus simply emulating x86 has netted some massive performance gains on Apple Silicon playing PS3 games. Framerates are seeing increases of anywhere from 50-100% just by running natively instead of being forced through x86 translation on top of intensive PS3 hardware emulation, making truly performant Arm-powered PlayStation 3 emulation a reality instead of a far-off dream.

Unlike the Raspberry Pi 5 testing which more or less approximates a PlayStation Portable, the Apple Silicon testing shows off high performance in some true PS3 powerhouses, including the likes of God of War III and Skate 3. These titles are much harder to emulate than PS2-to-PS3 HD ports like God of War HD, but they are still quite playable on Arm architecture hardware, so long as it has the muscle to back the experience.

A tech tinkerer decided to put the homebrew Nintendo 3DS port of DOSBox to the ultimate test — running Windows 95. Using the souped-up version of the 3DS, the "New" 3DS with additional RAM and processing power, TechTuber MetraByte was able to install the DOSBox port successfully and, subsequently, the Windows 95 operating system directly on top of that DOSBox instance. The load times involved seemed quite long, too, especially when he decided to leave the handheld alone overnight while on his first boot of Windows 95. In contrast, the OS installer only took about five minutes. However, proper mouse input support (via Touch through DOSBox) didn't start working until well after the operating system had been launched on the hardware.

Now, the good news first: Windows 95 does in fact run on the New Nintendo 3DS. And at least in terms of memory spec, that makes sense, since Windows 95 was made to run on as little as 4MB of RAM — though of course, that's for x86 machines and scenarios outside of emulation. The New Nintendo 3DS' allocation of 256MB of RAM is very slim by today's standards, but quite good for the era of software prior to commonplace Gigabytes of RAM. However, DOSBox doesn't only have to work with the system memory — it also has to do x86 emulation on the New Nintendo 3DS' Arm-based hardware, which is where such a severe performance deficit is incurred.

So, while you can get Windows 95 running on a New Nintendo 3DS, there's definitely no reason that you should. The installation will prove long and tedious, and even once you boot into the operating system, not very much of it will be usable. Not even basic MIDI audio file playback was possible when MetraByte tested Windows 95 on the New 3DS. Attempting to run his music studio software of choice also outright bluescreened the device. But the OS did seem to at least function besides that, and perhaps the lightest software may still run.

Realistically, though, if you're doing anything with DOSBox on the New Nintendo 3DS, you definitely shouldn't be installing Windows. Instead, you should be trying out older DOS titles that probably will work just fine in these conditions, considering how genuinely powerful the New Nintendo 3DS was and how much overhead is saved by not running Windows 95 on top of everything else.

In the world of computer software, x86 and x86-64 are by far the leading CPU architectures in terms of overall software compatibility, particularly for legacy software with or without emulation. However, as YouTuber Inkbox has pointed out and tested, most modern AMD and Intel CPUs can still run pre-Windows DOS "to the metal" via plain old backward compatibility, no emulation needed.

For those who don't know exactly what "emulation" is, it's best to think of it as a piece of software that imitates a (usually) fixed hardware platform to then run software targeted only at that original platform. In modern consciousness, the most popular use case of emulation is for achieving backward compatibility with past game consoles, arcade boards, and retro PCs (often with non-x86 architectures) for retro gaming purposes. The cutting-edge of emulation also tends to add support for features like replacing models and textures or upping the framerate, often on a per-game basis.

As recapped by Inkbox, modern x86 and x86-64 CPUs go through something of a cycle when first booted up — their initial state, a 16-bit "Real Mode", closely imitates that of the original 1979 Intel 8086 before shifting into 32-bit or 64-bit depending on the specifications of the CPU in question. This Real Mode exists for the sake of backward compatibility and has been present in some form or another since the 80s and the influx of IBM PCs that ignited the home PC market around the world. Since an overwhelming majority of PC software targeted the Intel 8086, then, supporting its 16-bit instruction set became a vital feature of every successive x86 and eventual x86-64 CPU.

But what does all of this mean for you, the end user? Well, seeing as your PC most likely doesn't have a floppy drive, you'll likely need to follow Inkbox's footsteps by installing MS-DOS and all the programs you would like to run on it on a bootable flash drive through the Rufus utility. Otherwise, as long as your PC supports UEFI and a legacy BIOS boot mode, you should be good to go — but if your UEFI has no support for a "Legacy" mode at all, you may not be able to run DOS and its software "to the metal" as done in Inkbox's video.

In Inkbox's testing, an Intel Celeron N3450 is used. This is an "Apollo Lake" Intel CPU with "Goldmont" cores targeted at low-power Atom, Celeron, and Pentium devices from 2016, which is from the same era as Intel's 6th Gen "Broadwell" Core CPUs. Using an Icewhale ZimaBlade Mini PC with support for 16GB of LPDDR4 RAM, Inkbox was able to boot MS-DOS 8 and MS-DOS 1.0 straight "from the metal" by setting the flash drive as the boot device in the BIOS and subsequently play a variety of games including the original DOOM (1993), Tetris (DOS vers.1988), and even The Last Ninja (1987). However, he also chose to play without sound enabled due to suspected limitations of the ZimaBlade Mini PC, so YMMV on whether or not you should even bother with this methodology.

It is certainly cool that DOS can still be run like a modern OS on modern CPUs and motherboards that still support legacy BIOS operation. However, emulation (as well as the slightly different virtualization) and modern CPU power have gone so far that emulation overhead hasn't been a concern for decades. Additionally, emulation software does at least let you use the rest of your modern system and its modern OS as intended in the background, so it is probably preferable for the casual and curious.

Just yesterday, Twitter/X user @NTDEV_ posted a series of screenshots showcasing the Tiny11 Core build of Windows 11 running on their iPhone 15 Pro. The emulated specifications provided through the UTM SE PC emulator include a 1 GHz, 1-core virtual QEMU CPU and 2GB of RAM, so this is hardly an ideal use case for Windows 11 or an iPhone 15 Pro, but it's a fascinating showcase of both.

An important distinction to make before proceeding is that "emulation" and "virtualization" are two different concepts. Emulation imitates a specific hardware architecture and allows for hyper-specific software (a la software only released on obscure arcade boards or long-dead PC architectures) to be run on emulator-targeted platforms. Virtualization can be used for emulation, but instead refers to the ability of supported hardware to create virtual pools of resources (CPU cores, RAM, etc) to be dedicated to separate operating systems (often the same OS for different simultaneous sessions/clients) inside a virtual machine.

Close examination of the screenshots raises some red flags right away. For example, the resolution and aspect ratio are both quite cropped compared to the full extent of the iPhone's display, suggesting dreadful limitations in either emulation performance or configuration options. The screenshots all show very limited, single-window use cases, though text rendering and such still seems to be fine.

It's still impressive that this runs at all — particularly considering the much higher performance overhead inherent to emulating disparate CPU architectures compared to more standard same-architecture virtualization — but it's obvious that the main iOS 17 and upcoming iOS 18 will provide the more usable, visually-enjoyable experience.

As noted by @NTDEV_, the performance here isn't what one would call "usable" despite the acquirement of four screenshots. Taking twenty minutes to boot into any operating system on any modern machine is hardly tolerable, and iPhones don't have the same x86 software or hardware optimizations as modern Macs and Macbooks do. At this time, experiments like these are still in the range of "experimental" phone operating systems in general, like the 9-year-dead FireFox OS (RIP). It's quite the flex for both UTM SE and the Tiny11 guys, though.  

Despite its 1996 release, the Nintendo 64's original hardware and games have both remained relatively hot-button in enthusiast circles here into 2024. Now, the next frontier of high-end N64 gameplay may be through recompiled PC ports instead of emulation, courtesy of Mr-Wiseguy on GitHub. Wiseguy is responsible for the release of both N64Recomp and Zelda64Recomp, a project that ports The Legend of Zelda: Majora's Mask to PC with N64Recomp's graphical and QoL improvements, as screenshotted above and highlighted by YouTuber Nerrel below.

So, what makes crazy graphical improvements like real ray-tracing, uncapped FPS, and proper ultrawide support possible for N64 games? If you've been in the Nintendo 64 enthusiast scene for a long time, you may recall the waves made when a completely decompiled Super Mario 64 PC Port dropped in 2020 and allowed for features like real ray-tracing, full model replacements, and so on. It still gets mods to this day.

Recompiled ports aren't quite the same as decompiled ports like the SM64 PC port in this context, but both will run natively on PC and thus be able to truly maximize performance and effect accuracy to the original hardware while still providing the PC-expected enhancements that come with emulation.  N64Recomp is basically the best of both worlds, and since manually decompiling N64 games takes years of labor from one or more people, a tool to more efficiently recompile them into a quickly playable-on-PC state is a godsend for preservationists everywhere.

A tool like this also ensures that old classics that aren't currently receiving the attention of big mainstream hits remain playable well into the future in an ideal state. A Twitter post by Dario, who makes the RT64 plugin leveraged by N64Recomp and some N64 emulators, highlights this.

Even as we speak, advancements like this aren't the only huge boons we're seeing for fans of the Nintendo 64's library or even original hardware. The open-source SummerCart64 recently dropped and is basically the definitive flash cart for the old console since it also implements full 64DD support. Several real hardware-compatible homebrew N64 games and ROM hacks also keep releasing, including highlights like the 30-fighter Smash Remix and Mario 64 engine rewrite, Peach's Fury.

The latest version of Box64, a popular x86_64 emulator for Linux running on architectures like ARM/AArch64 and RISC-V, introduces significant performance improvements, making possible gaming on RISC-V-based platforms such as the Vision Five 2 board, reports Phoronix. 

The most important addition to the Box64 version 0.2.4 is that Dynarec now works on RISC-V. This facilitates faster operations of x86_64 Linux software on RISC-V 64-bit system and makes simplistic games, such as Stardew Valley, playable on Vision Five 2-based devices. Additionally, the new version introduces several fixes for Steam, enhanced multi-threading capabilities, and broader improvements for emulation across various CPU architectures.

While titles like Stardew Valley can hardly attract avid gamers, the Vision Five 2 is not exactly designed to run games (even though it has an OpenGL ES 3.2, Vulkan 1.2-capable integrated GPU), so running a game is already a kind of a breakthrough for this product. The motherboard is aimed at software developers and is based in the quad-core StarFive JH7110 SoC with SiFive U74 RV64GC cores running at 1.50 GHz and Imagination's  BXE-4-32 GPU.

The Box64 version 0.2.4 has refined its compatibility with several modifications, which includes better handling of ELF files, added wrapped libraries and functions, expanded opcode functionalities, and preliminary WoW64 support for 32-bit operations in Wine. 

In conjunction with Box64's release, Box86, focused on x86 32-bit emulation, launched its 0.3.2 version. This version sees improvements in system call processes, an optimized ELF loader, a decrease in memory usage, and stability improvements.

The Raspberry Pi is a notoriously small SBC and half the fun of looking through hundreds of Pi projects is finding cool places people manage to hide them. Today we’ve got a neat project to share from a maker known as Cubey125 over at Reddit. Cubey125 has put a Raspberry Pi inside the dashboard of their Nissan 370Z and fixed it up with RetroPie for gaming on the go.

RetroPie is the goto application for many gamers in the Raspberry Pi community. It’s a one-stop shop for tons of emulators which makes it easy to get off the ground with retrogaming and customizing your projects to your liking. We have a guide on how to set up RetroPie if you’re interested but there are other applications you can choose from, as well, like Lakka or straight up RetroArch.

For this project, Cubey125 is taking advantage of the Nissan 370Z dashboard which has a built in screen. The screen has a composite jack which they were able to use to connect the Raspberry Pi to for video output. Details are scarce on how this was accomplished but you can find HDMI to composite adapters that would get the job done.

Controlling the Pi and launching RetroPie sometimes requires the use of a mouse and keyboard. To make things easier, Cubey125 put a wireless keyboard and mouse in the glovebox. For video game input, a wired Xbox controller is connected. That said, you could always replace it with a wireless controller of your choice depending on what you have on hand and what model of Pi you’re using.

There are already plans in the works to spruce up the rig with even more features. Cubey125 mentioned the possibility of dual booting the Pi to run Ubuntu on the side. It would also be possible to use an OBD2 setup for real-time stats from the 370Z which seems highly appropriate given the project is already integrated with the car.

If you want to get a closer look at this Raspberry Pi project and see it in action, head over to the original thread shared to Reddit and be sure to follow Cubey125 for future updates.

Microsoft is pulling out all the stops to prevent emulators from being used by mainstream gamers on its Xbox series consoles. A few months ago, the Xbox team announced that emulators running in "retail mode" would no longer be legal, and banned all emulators from the Microsoft Store. However, the situation quickly escalated when a group of developers found a loophole in the system. As a result, Microsoft is now handing out 15-day suspensions to anyone desperate enough to run emulators outside of developer mode (due to the loophole).

Emulation is the defacto way to keep really old classic games, say from the PS1 era from going the way of the Dodo. With emulation, gamers can continue playing these really old games on modern computer hardware. However, due to the additional cost of running emulation, many gamers prefer to use hardware like the Xbox series consoles to play emulated games since these consoles have really powerful CPUs compared to other consoles (like the Nintendo Switch).

In fact, Microsoft's Xbox series consoles are so powerful that they can run emulated games at higher resolutions and extra graphical options than originally intended.

Apparently Microsoft never officially disclosed why emulators were banned, but Azure developer Alyanna McKenna on Twitter shared some insider knowledge from the Xbox QA team about the ban. According to her tweet, Microsoft banned emulators due to copyright protection issues with Nintendo. Emulators published on the Microsoft Store can come pre-bundled with Nintendo games that are not legally allowed to be played by the application.

Additionally, the tweet goes on to say that these emulators can require permissions beyond the typical use case for a game or app on an Xbox console, and banning emulators altogether can close this security loophole as well. Now, it's worth noting that this is not an official Microsoft press release, but it gives us good insight into its decision-making on the matter.

However, this did not stop developers and hackers from making a workaround to get past the ban altogether. Apparently, a few months after Microsoft put the ban in place, a group of emulation developers were able to exploit a fault in Microsoft's software that allowed their emulator to run in an Xbox console's normal mode or "retail mode" (more on that later). As a result, Microsoft has now added an additional 15-day suspension for anyone gutsy enough to try this workaround.

Thankfully this problem is not that serious, for some reason Microsoft still allows Xbox gamers to run emulation apps as long as the console is running in "development mode" instead of "retail mode". A development license only costs $20 so it's a very easy way to re-enable emulation support on an Xbox console legally. But, given how stringent Microsoft has been with its current policy, don't be surprised if this "loophole" also gets banned in the future.

When it comes to emulation, there’s nothing quite like the ingenuity of the Linux community. Today we’re sharing a neat project from maker and developer Paul Rickards, aka Biosrhythm. Using a handheld Linux platform known as PocketCHIP, Rickards has set up a Mac II emulator known as Mini vMac. If PocketCHIP sounds familiar, it's probably because we've previously covered a Raspberry Pi version designed to work with a Raspberry Pi CM4.

The PocketCHIP unit is battery-powered which makes it totally portable. It’s intended to work with Linux operating systems, but you do have a bit of flexibility when it comes to choosing an OS. It features a QWERTY keyboard for user input and also sports a 480 x 272px touchscreen for video output.

According to the official documentation, Mini vMac is an emulator collection designed to bring compatibility with old Macintosh software on newer hardware. Mini vMac is part of the Gryphel Project, which intends to preserve Mac software from 1984 to 1996. And thanks to this PocketCHIP project, you can now take the old-school Mac experience with you on the go.

When Rickards set out to run Mini vMac on the PocketCHIP, he was delighted to discover a package already put together by another maker known as Zzxzzk115 (you can find this package over at GitHub). This configuration is made just for PocketCHIP but required a little bit of work from Rickards to get up and running on the handheld.

Setting up Mini vMac will vary depending on what OS you’re starting with. In this case, Rickards is using the Jessie distribution of Debian so it took some extra steps to get off the ground — which might not be necessary if you’re running Bookworm (the latest). You can follow along with Rickard’s steps over at his official Biosrhythm blog.

If you want to recreate this setup, or even turn it into a Raspberry Pi project, check out the original blog post shared by Rickards — and look into the CM4 version of the PocketCHIP to make it Pi-flavored. 

It’s no secret that we’re huge fans of retro gaming here at Tom’s Hardware. But while most of the retro gaming projects we cover are in the form of Raspberry Pi emulators or running Doom on things that shouldn’t be running Doom, today’s project takes everything we’ve seen about retro gaming in the modern era and flips it on its head. Meet TinyTendo—the pocket-sized NES experience created by a maker known as Redherring32 that uses actual NES hardware. No emulation is used in this project at all.

If you’re wondering how Redherring32 managed to cram an NES inside such a small form factor, we’re clear that no shrink ray was used in the development of this project. Rather, Redherring32 carefully cut original NES hardware and ground the edges until the components fit inside the shell. The final product weighs in around 10 oz, uses 4 AA batteries like an original Game Boy, and is housed comfortably inside of a custom shell with dimensions of 148 x 90 x 32mm.

According to Redherring32, the final chips that he cut take up less than 7% of their usual size. They also fit onto a custom PCB that’s smaller than a Raspberry Pi 3. The hardware was physically cut and sanded by hand and finished with a Dremel tool.

In addition to using original NES hardware, it also includes some features that make the unit stand out as a viable modern handheld. Of course, it has an integrated screen and buttons on the front for input. It also uses a USB-C port for charging, a special switch is included to adjust the voltage between 5V and 3V to save power and the power button is a latching push switch like the original NES. There’s also a special brightness control module created by YveltalGriffin.

Because it’s using original hardware, you may be curious how it loads games to play. Instead of storing everything on an SD card and building some sort of interface, this project uses custom made tiny cartridges. They plug into the back just like a Game Boy game but load NES games. These mini cartridges were created by a maker known as BucketMouseBite. Redherring32 confirms, it’s possible to use original carts with the setup but an adapter would be necessary.

If you want to get a closer look at this project, check out the original thread shared to Twitter by Redherring32. We would also like to assure that only one NES with a damaged motherboard was used to build this project.

We’ve been excited for the Asus ROG Ally handheld for a while and, now that it’s here, we’re eager to see what all it can do. In our review of the Asus Ally, we noted that it offers good performance and a bright screen, but mediocre battery life. And when you compare the Asus Ally vs the Steam Deck, it's a tie because each has its strengths when playing PC games.

But what about emulation? How well does Asus's new handheld play games made for consoles. YouTuber ETA Prime was determined to find out and shows us in the video below. The results are very promising as the Ally is able to handle games from PS3 (usually an emulation challenge), the Nintendo Switch and Xbox 360.

On the lighter end of the emulation spectrum, ETA Prime demonstrated it’s ability to play PSP games with ease using PPSSPP. It can also handle 3DS emulation using Citra, a Nintendo 3DS emulation platform. These systems are less demanding hardware-wise than consoles so it goes without surprise that the Asus ROG Ally handled them so well.

As far as consoles are concerned, ETA Prime also demonstrated its ability to run GameCube ROMs using Dolphin. PlayStation 2 games were also on the table thanks to PCSX2, a Windows-compatible PS2 emulation platform. From the same era, we also got a look at Xbox emulation with CXBX. It handled the WiiU fairly well using CEMU and brought us to the modern era of consoles by emulating the Nintendo Switch. In addition, it could handle Xbox 360 and PS3 emulation with reliable playability.

The Asus ROG Ally runs Windows so Steam access is a given. However, if you’re looking for an emulation platform there’s definitely great potential to be had. If you want to get a closer look at the Asus ROG Ally in action, check out the demonstration video shared to YouTube by ETA Prime.

If there’s one thing the Raspberry Pi community does well, it’s push the boundaries of what these boards are capable of. Maker Vlad Tomoiagă has done just that with this exciting RISC-V emulator project. Based on Mini-rv32ima, created by CNLohr, this Pico version, dubbed Pico-rv32ima, is able to run Linux.

The project relies on the Mini-rv32ima emulator core which enables the Pico to run Linux. According to Tomoiagă, it uses two 8 MB SPI PSRAM chips as memory with 4 kB of cache to prevent bottlenecking from the SPI interface. Tomoiagă explains this idea came from the uc32-rvima project created by a maker known as xhackerustc.

When the Raspberry Pi Pico is booted, the Linux image is copied over to the RAM before loading Linux kernel text to the console. It takes about one minute and thirty seconds for the system to completely boot. Tomoiagă was kind enough to share a video demonstration of the boot process for any interested parties.

It doesn’t take too much hardware to recreate this project but Tomoiagă warns that the project both overclocks and overvolts the RP2040 processor and to proceed at your own risk. Because the Pico is an affordable board, the risk isn’t all that high and we think the end result is well worth living on the edge for. You’ll need a Raspberry Pi Pico but you can many of the best RP2040 boards along with a microSD card. Two 8 MB SPI PSRAM chips are necessary. In this case, Tomoiagă is using LY68L6400 chips.

The SD card connects via SPI interface. The console can be accessed over UART, USB-CDC, or on a display. In an example, Tomoiagă is using an ST7735 display which has a resolution of 128 x 160px. This is paired with a PS2 keyboard for user input. The code used in this project was primarily written in C and is available on the official project page at GitHub.

If you want to make this Raspberry Pi project yourself or just get a closer look at how it works, visit the project’s GitHub page and be sure to follow Vlad Tomoiagă for more cool projects as well as any future updates on this one.

There’s no better retro computing companion than the Amiga. From its rich history to the classic old-school design, modern computers just don’t feel the same as that era of home computing. Itching to get that old feeling back into his life, Rob Fisher decided to build an Amiga 1200 emulation project using none other than our favorite SBC—the Raspberry Pi. Not only does this project look like an Amiga, it sports a working floppy drive that the Pi is able to interact with thanks to a clever interface card.

To build the project, Fisher is housing a Raspberry Pi inside of a modern Amiga 1200 replica shell. While you could easily use almost any Pi for this project, he opted to use a Raspberry Pi 4 to power the machine. To make full use of the case design, the ports on the Pi have been routed to the outside of the shell for access, including the floppy drive. This makes for a seamless experience as the project consists of just one unit unless you plug in some accessories.

Fisher shared a video to YouTube breaking down the project design from the inside and out. In this video, he shares not only the hardware inside but where he got the components so you could easily recreate it at home. According to Fisher, this is a work in progress but we’re still impressed with the project so far.

As we mentioned above, the main hardware used in this project is a RaspberryPi 4 set inside of an Amiga 1200 shell. In addition to the Pi, he’s using an A500 keyboard from eBay for input. A Greaseweazle floppy adapter board is used to help the Pi interface with a PC floppy drive. All of the ports, including the floppy drive, are mounted with extensions so they can be easily accessed from the outside of the case. A 3D-printed button is used to release the floppy drive.

In another video, Fisher gives us a look at what the Amiga project looks like in action. It’s running Pimiga 3, an Amiga emulation application that can be programmed to get the classic look and feel of the original operating system. If you want to read more about emulating the Amiga, check out our guide on how to emulate the Amiga on a Raspberry Pi. In the demo video, Fisher also demonstrates the floppy drive is completely functional by popping in a few Amiga magazine cover disks to see how they perform.

If you want to get a closer look at this Raspberry Pi project, check out the original video shared to YouTube by Rob Fisher and be sure to follow him for future projects as well as any updates on this one.

There may not be a Raspberry Pi 5 in 2023, but Raspberry Pi alternative Radxa has announced the Rock 5A which bears a striking resemblance to the Raspberry Pi 4 but this particular board offers up to 8K video support and up to 16GB RAM.

Radxa's Rock 5 will be available from the end of Q1 2023. The board features an RK3588S SoC with an octo core CPU. Four of the cores, Arm Cortex A76, run between 2.2 and 2.4 GHz, much higher than the Raspberry Pi 4's 1.8 GHz A72 CPU. The smaller cores of the RK3588S are Arm Cortex A55 running at 1.8 GHz. The RK3588 has been gaining ground and features in a number of SBC, for example the Firefly RK3588S and Pine64's QuartzPro 64. Video decoding is supported at up to 8K 60, a very attractive feature for the $99 price point.

So why is the Rock 5A an interesting alternative to the Raspberry Pi? Chiefly it comes down to price and performance. For around $99 we can per-order the 4GB model, which offers plenty of RAM for most SBC users. Retro game enthusiasts will most likely choose this model as it offers plenty of RAM to emulate classic games, including some from the PlayStation2 era. Yes, PS2 is now considered retro and we feel considerably older for it.

The camera connector looks to be compatible with cameras similar to the official Raspberry Pi cameras, but that can only be confirmed when we get one in our hands. As for the GPIO, don't expect it to be Raspberry Pi compatible.  While it could be electrically compatible with your favorite HATs and add-ons, software support may not be.  The onboard M.2 slot supports SATA and thankfully has a binding post inside the board's footprint. If we can boot from this drive then we have a compact and relatively fast SBC. If you prefer eMMC, then on the underside of the board we have an eMMC interface. Speeds will likely fall between micro SD and SATA. Also on the underside, just by the USB ports, is an RTC (Real Time Clock) battery connector, looking at the silkscreen we can see that this JST connector provides power to an onboard RTC.

We look forward to taking this board for a spin later this year.

Over at Twitter, Paulo7x8 has unveiled his exciting new PlayStation 1 Optical Disc drive Emulator (ODE) project which uses our favorite microcontroller—the Raspberry Pi Pico. It’s designed to read disc image files for the original PlayStation and can trick the original console into reading them as if they were a real disc.

The Pico serves as an interface between the PlayStation CD drive and the microSD card attached to a custom PCB  that sees the Raspberry Pi Pico surface mount solder to it. ROMs, in this case, disc image files, are stored on the microSD card. The PCB is connected to the PlayStation which recognizes the connection as a disc inserted in the disc drive. This enables the system to send ROM files directly to the original hardware.

This is exciting for fans of the original PS1 that prefer to emulate using original hardware. Exercise caution when proceeding with retro gaming emulation as there are legal concerns with using copyrighted ROMs and disc images that vary between countries. You can always find free and legal homebrew ROMs that often provide alternative games developed by PlayStation enthusiasts.

The only hardware you’ll need to recreate this project is the PCB created by Paulo7x8, a Raspberry Pi Pico, microSD card and an original PlayStation. There are similar kits on the market, like the XStation Optical Discdrive Emulator ODE Mod Kit but it doesn’t use a Pico. You can check it out over at Castle Mania Games.

As of writing, the project is not yet available for users to download or purchase. However, Paulo 7x8 did confirm future plans to make the project open source so users will be able to access the original PCB files as well as peruse the code that makes it possible. Until then, you can check it out over at Twitter to see it in action.

If you want to recreate this Raspberry Pi project, be sure to follow Paulo7x8 to keep up with updates and find out when its available.

Ever wanted a pocket-sized computer that can play DOS games and do pretty much everything else a 486 or Pentium PC could do? Then look no further. TInyLlama, AKA Eivind Bøhler from Norway, has put together a board -- featuring an 86Duino SoM and a Raspberry Pi Zero 2 for MIDI -- that can do just that, and thoroughly documented it on GitHub. Beware, though, you’ll have to build it yourself.

At the core of the clever custom board is a Vortex86EX CPU - a 32bit X86-compatible IA-32 CPU made in Taiwan by DM&P Electronics - running at between 50 and 500MHz, a speed no 486 or original Pentium could even dream of. There's 128MB of DDR3 RAM, again much greater than the 16MB that was common at the time, and 8MB of programmable flash ROM. A Vortex86VGA module runs off a PCIe 1x lane, offering a maximum resolution of 1024x786, at a period-appropriate aspect ratio of 4:3. Storage comes via Micro SD, and power from a micro USB cable.

Sound comes via a Crystal CS4237B all-in-one audio chip, which is Sound Blaster Pro compatible, but you can supplement this with a Raspberry Pi Zero 2 attached via a 40-pin connector that supplies Roland MT-32 emulation and general MIDI. There's a switch for toggling between its two modes, and you can connect an OLED display using a four-pin I2C plug.

Software support comes in the form of a custom Coreboot/SeaBIOS ROM, and it runs FreeDOS or the OG MS-DOS itself. There's no mention of Windows 95, though the Vortex86EX chip should be able to handle Windows CE 6, Windows Embedded Compact, and Linux up to kernel 4.14.

There’s a lot of soldering to be done if you fancy building your own TInyLlama, especially as the SOM-128-EX system-on-module that forms the core of the device has completely the wrong pin layout and needs to be customized. You then need to replace the pre-installed bootloader and program the sound chip firmware. If you’re up for the task, the design is open-source, and there's a full walkthrough plus BOM on the TInyLlama GitHub page.

AMD's Ryzen 9 7950X has grabbed a top spot in RPCS3, a multi-platform open-source Sony PlayStation 3 emulator. The CPU outperforms all of its predecessors as well as rivals from Intel. RPCS3 gained AVX-512 support earlier this year, and AMD's latest CPUs based on the Zen 4 microarchitecture fully support AVX-512 instructions. 

AVX-512 support brings a 30% performance improvement to RPCS3, which is enough to make AMD's Ryzen 9 7950X the most powerful CPU to emulate PS3 using this emulator. Evidently, increased single-thread performance of AMD's Zen 4 plays a big role here as well since the CPU outperforms AVX-512-enabled Intel's 11th Generation Core 'Rocket Lake' processors (via Reddit). 

Intel's AVX-512 instructions are perfect for emulating Sony's PlayStation 3. This console is based on the Cell CPU featuring one general-purpose Power core and eight synergistic processing elements (SPEs) featuring a proprietary instruction set architecture with in order execution and 128-bit SIMD organization. The Cell processor offered explicit parallelism and large file registers, a combination that AVX-512-supporting multi-core CPUs fully support. Meanwhile, the popular LLVM compiler can automatically choose the best code path that can be executed and in case of AVX-512-enabled hardware it brings a 30% performance uplift. 

Truth to be told, contemporary gaming PCs are powerful enough to emulate Sony's PlayStation 3 game console from 2006, and most of them should be good enough to play some old games and relieve experience from 15 years ago. Meanwhile, RPCS3 can add some eye candy using AMD's FSR technology as well as some additional framerates courtesy of modern hardware to get a more 2022 experience. 

It remains to be seen how AMD's Ryzen 9 7950X processor stacks up against Intel's Core i9-13900K, but we are pretty sure that the former CPU will continue to lead  — at least in applications that take advantage of AVX-512 instructions. A 30% performance bump is hard to offset with high clocks and large caches alone. 

A Linux OS and Nintendo Switch enthusiast has mind-melded the two disparate systems to create Horizon Linux. In brief, a Redditor by the name of Kent J Hall has patched the Arm64 Linux kernel to run Nintendo Switch games natively. Hall stresses this isn’t an attempt to recreate Nintendo’s Horizon OS, and it isn’t meant to run on Switch hardware – rather the project simply hopes to make Switch games on any Arm64 hardware platform.

After a false start or two, Hall decided to spend a chunk of his free time on the Horizon Linux project summarized above. Patching Arm64 Linux seemed the sensible route to reach his goal as it meant “you get Linux’s vast hardware driver support for free, so not only can it be virtualized on Apple silicon Macs, but it can run bare-metal on any arm64 hardware which supports Linux,” explained Hall. The project should work fine “even on lower-end hardware, given that there’s no need to emulate the CPU,” he added. Moreover the project is flexible, and holds promise for game preservation.

Horizon Linux’s development was greatly helped by taking an existing open source Switch emulator, called Yuzu, and taking the scissors to unneeded parts of the code such as kernel and CPU emulation - while retaining things like the system services, GPU emulation and app loader. The developer also notes that he spent some considerable time getting each system service to run persistently in its own thread.

The Redditor behind this project decided to go public with it at this time, as it has reached a significant milestone. Admitting the work was “far from complete,” Hall says that the first commercial game, Puyo Puyo Tetris, is playable on Horizon Linux.

Hall has published some videos showing Puyo Puyo Tetris running on an M1 Max MacBook Pro, and an Nvidia Jetson Nano. The videos are sadly not available at the time of writing, and we don’t know why. Please note, as mentioned above, the game is running natively on the Arm CPUs of these systems. However, it is still going through the same GPU emulation layer that Yuzu uses, despite the Jetson Nano (for example) featuring the same Tegra X1 GPU as the Switch.

It's worth noting that several Raspberry Pi computers, including the Raspberry Pi 3 and 4, have Arm64 CPUs However, it looks like no one has yet tested Horizon Linux on a Pi.

Hall has recently started a new job, so it looks like some encouragement will be required for him to stick to the project. If you have an Arm64 system you want to test Horizon Linux on, you can comment on the Reddit post from the developer, linked top, and/or visit the Horizon Linux GitHub repository.

Interestingly, Hall was apparently unaware of the Skyline Nintendo Switch emulator for Arm / Android. Since the Reddit post started getting noticed, there looks like a chance for some cross-pollination to occur, as one of the major Skyline developers has asked the Horizon Linux developer to join their Discord.

Native DX9 hardware support is officially gone from Intel's Xe integrated graphics solutions on 12th Gen CPUs and A-Series Arc Alchemist discrete GPUs. To replace it, all DirectX 9 support will be transferred to DirectX 12 in the form of emulation.

Emulation will run on an open-source conversion layer known as "D3D9On12" from Microsoft. Conversion works by sending 3D DirectX 9 graphics commands to the D3D9On12 layer instead of the D3D9 graphics driver directly. Once the D3D9On12 layer receives commands from the D3D9 API, it will convert all commands into D3D12 API calls. So basically, D3D9On12 will act as a GPU driver all on its own instead of the actual GPU driver from Intel.

Microsoft says this emulation process has become a relatively performant implementation of DirectX 9. As a result, performance should be nearly as good, if not just as good, as native DirectX 9 hardware support.

This DX9 change from Intel appears to be a very good move as a result. Intel can now divert driver development resources towards DirectX 11 optimizations -- which we know is very bad at this time, and Intel won't suffer performance consequences as a result, with DX9 optimizations "outsourced" to Microsoft entirely.

According to Microsoft, with how performant D3D9On12 is, it will be interesting to see if Nvidia and AMD follow the same path as Intel. But, there could be consequences to the API translation, including higher CPU usage (since the translation is software accelerated) and potential side-effects with older games. Nvidia and AMD also have almost 20 years of driver experience with DirectX 9, which might result in performance losses with the DX12 emulation layer.

Intel, on the contrary, only has experience with DirectX 9 on its integrated graphics, which does not translate into the experience with its much higher-performing discrete graphics. So it makes a lot of sense that Intel is immediately transitioning to emulation as it gets closer to launching Arc worldwide.

Everybody knows the ZX Spectrum was better than the Commodore 64, but what’s even better is Spectrum emulation on the RP2040 chip, better known as the Raspberry Pi Pico, with video output that suits modern screens. 

Brought to our attention by the official Raspberry Pi Twitter account, the emulator is the work of the wonderfully named Fruit-Bat on Github, where they have also ported MAME to the Pi. 

The software has some advantages over the original 48k and 128k ZX hardware: quick-save slots, compatibility with USB keyboards and joysticks, an on-screen menu system and the ability to load from .z80 snapshot files and .tap tape images. The whole thing is still a work in progress, with Sinclair and Kempston joystick compatibility added just a few days ago.

The project recently moved over to Pimoroni’s FatFS MicroPython library from no-OS-FatFS-SD-SPI-RPi-Pico due to a problem with SD card pins, and supports hardware from simple breadboards to the Pico-based RetroVGA universal computer emulator by bobricius.

Despite being at a relatively advanced stage, there are still issues with the emulation. There are currently many audio filters on GitHub, trying different treatments for the sound output, with the plea that if anyone discovers a particularly nice sounding one, they submit it. Our memories of the Spectrum are that it wasn’t a particularly nice sounding device, especially when loading games, but it will be good to see what the community comes up with. There's also an issue with the emulated Z80 processor being interrupted at the end of each 60 Hz frame. This is because the original machine sent frames at 50 Hz, but increasing the processor speed to 4 MHz (from 3.5 MHz) helps.

All the code for the emulator is available on Github, with complete instructions for building your own, and Fruit-Bat has posted a screenshot of it running the new ZX Spectrum game The Swarm is Coming without a rubber keyboard in sight, in case you were wondering what to do with it once you’ve compiled it.

We often pass by ESP32 builds on this site in favor of Raspberry Pi or RP2040-based slices of genius, but we couldn’t let this one go. The brainchild of Jeroen Domburg of spritesmods.com and brought to our attention by Hackaday, the tiny microcontroller inside this 3D-printed pinball machine turns out to be capable of more than just flinging a few metal balls. 

That’s because it’s running an X86 emulator powerful enough to set Digital Illusions’ 1992 DOS classic Pinball Fantasies in motion. The programming part of the build sounds pretty tricky, as Domburg was faced with code that contained comments in three languages, some in-jokes, and some gaps. 

“Pinball Fantasies was entirely written in hand-coded x86 assembly,” Domburg writes in his exceptionally detailed write-up of the project. “As I intended [to] use an ESP32S3 as the mind of the tiny pinball table, I couldn't use that directly; the Xtensa core in that chip doesn't know what to make of x86 instructions. So my initial idea was to slowly convert the code to C: assemble the x86 assembly files, link them to a framework of C files, then slowly convert routines from assembly to C until the entire thing was converted and all I had left was clean C code.”

Of course, that didn’t work out, so Domburg changed tack, interpreting the code as if it were written for a particular VM, then emulating that machine. Using an 8086 emulator written in C, he added the graphics, IO and DOS calls the game uses and no more. Domburg discovered along the way that while it only displays a slice of the table where the ball is, the entire pinball deck is kept in memory, meaning it can be tweaked to display the whole table if you want.

The hardware included an ESP32-S3, which sports a dual-core 240MHz Xtensa LX7 processor, half a meg of RAM, and comes with a useful integrated parallel LCD interface. That display is a 320x640 LCD, plus a little amp and speaker for audio and some buttons to provide input. Optional extras include a second LCD and a plunger to give the authentic pinball startup motion. The case is 3D printed, and if you want to have a go at building one, you’ll find even more information on Domburg’s Github.

Whatcookie, a software developer behind RPCS3, a multi-platform open-source Sony PlayStation 3 emulator, has released a patch that makes use of AVX-512 instructions and brings a 30% performance improvement to the emulator. So far, AVX-512 instructions have not made much sense for games. But in the case of a PS3 emulator, a large register file of AVX-512-enabled hardware, data level parallelism, and the LLVM compiler can do wonders.

But before jumping in to how AVX-512 instructions make sense for RPCS3, something that Whatcookie explained in his detailed blog post, let's take a short dive in the recent history of computing.

When you need to emulate Cell, you need explicit parallelism and large file registers, a combination that AVX-512 CPUs feature. As it turns out, the LVVM compiler automatically chooses the best possible code path, which in case of AVX-512-enabled hardware means an appropriate code path. For obvious reasons (we are talking about emulation here at the end of the day) it is not exactly ideal, not all mask registers can be used, for example.

AVX-512 also adds new mask registers which can be optionally used with EVEX encoded instructions,” wrote Whatcookie. “There are new comparison instructions which generate a mask in the mask registers as the result of a comparison between vectors. When a mask register is used as an operand all of the elements not selected by the mask will either be zeroed or leave the existing value in the destination register untouched. There are 8 mask registers, through k0 - k7, however only k1 - k7 can be used to mask things out, as k0 implicitly behaves as if all elements are selected.”

Nonetheless, the numbers speak for themselves. A 30% performance uplift is significant. Some may ask why bother about this kind of optimization considering the fact that we are already at well above 120 frames per second on our best gaming CPU,  Intel's Alder Lake Core i9-12900K? The answer is that there will be lower-power machines that will still benefit from this optimization. AMD's upcoming Ryzen 7000 processors will also have AVX-512 acceleration. 

When Sony introduced its PlayStation 3 based on the Cell CPU featuring one general-purpose Power core and eight synergistic processing elements (SPEs), a proprietary instruction set architecture with in order execution and 128-bit SIMD organization, the gaming industry was not exactly impressed since Cell was so much different than conventional processors of 2006. Something similar happened to Intel's AVX-512 instructions introduced with its 2013 Xeon Phi 'Knights Landing' supercomputer accelerators and later added to Skylake-X desktop CPUs (and the appropriate generation of Xeon Scalable). 

Thread level (multi-core/multi-thread) and data level parallelism (SIMD) are exceptionally good for high-performance computing (HPC), datacenter, encoding, and encrypting workloads, and even games, yet they are sometimes hard to exploit. Hardware base, code complexity, costs, time-to-market, and numerous other considerations drive decisions not to invest resources in development of software that would use every single client side CPU (or GPU) innovation that is out there. This approach to video games is considered good enough, which is one of the reasons why both Microsoft and Sony are on x86 (with AVX2, but without AVX-512) with a conventional Radeon graphics architecture.

There’s nothing quite like playing old school games on old school hardware and no one knows that better than maker and developer JamHamster. Today we’re excited to share an update on JamHamster’s Raspberry Pi retro CRT TV gaming console project which began a few months back and has finally reached a point of completion as demonstrated in a video shared this week to Twitter.

We first covered the progress on this project in late March, showing off the beautiful interior and custom metalwork used as a mounting platform that JamHamster took the time to design from scratch. The hardware rests inside of an old Realistic brand Portavision 7 TV purchased used online. This project reuses the shell of the television but also takes advantage of the flexibility of more modern tech. Gone is the large glass CRT screen, in favor of an IPS screen and curved lens giving the 4:3 image that retro look. Running the show is a Raspberry Pi which uses an RGBerry HAT to add RGBS and SCART outputs for a more classic retro gaming experience using an actual CRT television. That said, an external display isn’t necessary as this build features an 8-inch IPS screen housed behind a thick curved lens crafted by JamHamster from a solid chunk of acrylic. This lens creation process was detailed thoroughly on his blog.

JamHamster is no stranger to handmade Pi projects. In fact, he has an extensive history of crafting sleek metal cases and integrating retro hardware into one-of-a-kind finished projects. Some of his original creations include this shiny all-metal arcade cabinet and this all-in-one arcade joystick platform. He's also created a variety of projects that are housed inside of hardware like this Spectrum ZX PC emulation project that runs inside of an old cassette tape, this Raspberry Pi 3A+ powered GameBoy and this Sega Game Gear that runs RetroPie.

You can expect JamHamster as an upcoming guest on our Raspberry Pi-themed show, The Pi Cast, to show off the final project and its new features. Recent design additions include a glowing SD Card slot that lights up orange, a signature accent color for JamHamster creations, when the Pi is powered on as well as subtle professional details like custom ribbon cables.

To see the new demo video of the final Raspberry Pi project, check out the original thread shared to Twitter and be sure to follow JamHamster for more cool creations and sleek custom designs. Don’t forget to tune into The Pi Cast for an interview with JamHamster and an up close look at this clever retro TV gaming rig.

Retro gaming and Raspberry Pi go together like peanut butter and jelly. This project, developed by Reddit user Mw33212, cranks the retro gaming concept up to 11 by not only making this handcrafted wooden retro gaming rig portable but also implementing a built-in projector for on-demand video output.

A quick look at Mw33212’s profile shows an impressively extensive history of handmade wooden projects with an affinity for tossing microelectronics into the mix including creations like this portable walnut audio player and this Raspberry Pi 4B wooden laptop.

According to Mw33212, this project was developed as a gift for their brother. Everything was devised from scratch including the components, overall design and of course the wooden housing. Mw33212 explains the wood case was made primarily using hand tools with the occasional assistance of a cordless drill.

Inside the box, you’ll find a Raspberry Pi 4B powering the rig along with a small amplifier module, used in conjunction with internal speakers for audio output. For video, it relies on a P09-II Portable DLP Mini Pocket Projector which is capable of outputting a WVGA resolution of 800 x 480, more than enough for this era in gaming.

In order to make things portable, it’s backed up with a 4-cell 18650 Lithium battery module. A power button is included for powering up both the projector and Pi. Because this is a retro gaming system, a couple of wireless rechargeable controllers are needed for cable-free multiplayer gaming. Keeping everything cool are two mini fans.

Instead of using the popular retro gaming platform RetroPie, Mw33212 opted to go with Emulation Station for running ROMs. Mw33212 explains the battery system lasts long enough for a full length movie but hasn’t been tested fully to verify its maximum lifespan. Port access has been made available for USB-C charging and SD card access while a hidden panel is built into the top for adjusting projector settings.

If retro gaming Raspberry Pi projects are your speed—or maybe you’re just a sucker for wooden Pi cases—you should definitely take a closer look at the original project thread at Reddit for more details, pictures, and an in depth look at its design. Be sure to follow Mw33212 for more cool projects and hand crafted microelectronics creations.

A moderator on the Intel forums confirmed that Intel's consumer-focused Arc Alchemist GPUs will not feature hardware-accelerated FP64 cores, relegating the GPUs to native FP32 and FP16 support. The only exception to this is emulated FP64 support on Arc Alchemist which will be supported for niche cases. However, due to the nature of emulation, FP64 calculations on Arc will run much slower than on GPUs with native hardware-accelerated FP64 cores.

Keep in mind that this configuration only applies to Intel's gaming-centric Arc Alchemist GPUs, not its upcoming Ponte Vecchio GPUs for the enterprise space.

FP64 is a computer number format commonly used in high-performance computing (HPC) applications. In addition, the large format has proven advantageous in very complex mathematical applications, such as physics, weather predictions, and simulations of many sorts, thanks to the wide dynamic range of numeric values FP64 provides.

However, FP64 is really only beneficial in the enterprise realm and has rarely ever become useful in the consumer space. Simply put, FP64 provides such a wide amount of numerical values that it's too big of a number to process for smaller calculations, done in workloads such as 3D gaming. In general, smaller calculations can be performed quicker on cores with FP32 and even FP16 capabilities. This is why you see consumer-focused gaming GPUs prioritizing FP32 and FP16 performance over FP64.

For instance, if we take a look at the GeForce RTX 3090 featuring Nvidia's latest Ampere architecture, you'll find that its FP32 performance comes in at an impressive 35.58 Teraflops. But the RTX 3090's FP64 compute capabilities pale in comparison to that performance metric, coming in at just 556 Gigaflops (not even a single Teraflop) -- or just 64th the performance of the GPU's FP32 capabilities.

This demonstrates just how unimpressive FP64 is in the consumer space. In the real world, this kind of FP64 performance is only beneficial for FP64 demos or benchmarks and rarely anything more.

With this in mind, it seems Intel's strategy to completely negate any hardware accelerated FP64 support on Arc Alchemist might be a good thing. The lack of "useless" FP64 cores gives Intel more room on the GPU dies to add important hardware, such as more FP32 or FP16 cores, additional hardware encoders and decoders or bigger caches.

Though many users are shopping for the best 4K gaming monitors to play the latest games, the best price/performance ratio is still with QHD panels. They can run at higher frame rates, up to 240 Hz in some cases, and deliver smoother motion resolution without requiring a top-of-the-line video card. It’s no surprise that it’s a hot category and 32-inch screens are of particular interest. With 93ppi pixel density, they provide a sharp picture and an immersive experience.

BenQ has added a curve to its recipe for the Mobiuz EX3210R. It features a 1000R curve, which is currently the smallest radius available. This means that the edges of the screen wrap sharply around the viewing position. It’s possible to create a nearly 180-degree field of view with three of these monitors. The EX3210R is a VA monitor with 165 Hz, Adaptive-Sync, HDR and extended color. It also has the rare ability to run blur reduction and Adaptive-Sync simultaneously. Let’s take a look.

BenQ Mobiuz EX3210R Specs

The BenQ Mobiuz EX3210R certainly delivers on the price/performance ratio. For around $600 at this writing, you get a gaming monitor with plenty of screen real estate, a colorful image, and good gaming performance. 165 Hz delivers good frame rates, which pushes motion resolution higher. Adaptive-Sync works on both Nvidia and AMD platforms over a 48-165 Hz range. The EX3210R has not been certified by Nvidia.

On the image front, you get HDR10 support with DisplayHDR 400 certification and a VA panel delivers high native contrast. BenQ states 2,500:1 in its specs, but I measured around 2,000:1 in my tests. However, that’s still higher, both measurably and visibly, than the best IPS screens. The BenQ Mobiuz EX3210R also sports a wide color gamut. I measured over 88% coverage of DCI-P3, which is about average for the category. Color accuracy is very good for both gamut and grayscale. I noted a gamma anomaly that I’ll tell you more about on page four.

Physically, the EX3210R represents BenQ’s excellent build quality and attention to detail. There’s a cool LED lighting feature on the back that comes with a variety of colors and effects. In addition to an OSD control joystick, a remote is included, which makes changing settings super-easy.

You also get BenQ’s unique features: Brightness Intelligence Plus and HDRi. The former is a front bezel sensor that detects room light levels and color temperature and adjusts those same parameters for the image. It is a subtle but useful effect that can help reduce eye fatigue and keep the picture looking consistent if your room has variable lighting. HDRi is an HDR emulation mode for SDR content. It isn’t strictly accurate, but the effect can improve the look of some content. Like any image enhancement tool, it’s up to user preference.

I mentioned earlier that the EX3210R allows the use of Adaptive-Sync and blur reduction at the same time. Very few monitors can do this, and here, it is a definite benefit. You can have a tear-free and blur-free image with no apparent reduction in performance or responsiveness.

Assembly and Accessories of BenQ Mobiuz EX3210R

The BenQ Mobiuz EX3210R ships very well protected in a clamshell-type box. I love these because it’s super easy to lift everything out without getting crumbly foam all over the place. The panel, upright and base assemble without tools. 

If you’d rather use a monitor arm, there’s a 100mm VESA bolt pattern in back, for which BenQ has kindly included the fasteners. The cable bundle includes HDMI, DisplayPort and USB. The power supply comes in the form of a large brick.

Product 360: BenQ Mobiuz EX3210R

The EX3210R follows the styling cues of BenQ’s Mobiuz line with simple forms and just a bit of red trim to announce the monitor’s gaming intent. The base is wide and deep and finished in silver, as is the backside. You can see the four light strips set into the otherwise smooth plastic. 

The grill in the top center houses a five-watt woofer that delivers better bass than just about any computer monitor I’ve tested. The main speakers fire at the user from front grilles set below the screen. It’s as close to a sound bar as you’ll get without adding something from the aftermarket. Sound quality is clearly a cut above the norm.

The remote is small and very handy. Up top are power toggle and input selector keys. After the nav pad, there’s a dedicated button for HDRi, which also selects the HDR10 mode. The controller icon changes the picture mode while the remaining keys adjust brightness, sound modes, main menu and volume. I found the remote to be the best way to change settings.

You can see the Mobiuz EX3210R’s extreme curve in the top view photo. It’s 1000R, which means a circle made from these monitors would only be two meters across. That’s the tightest curve currently available in a computer monitor. It produces an obvious wrap effect which works very well at this screen size. The 16:9 aspect ratio also means you get a lot more vertical information. The game environment easily fills the user’s peripheral vision.

The stand features a full array of adjustments – 5/15 degrees tilt, 15 degrees swivel to either side and a four-inch height range. Movements exude quality with a firm motion that’s free of play. The Mobiuz EX3210R’s build quality is excellent.

The input panel includes a single DisplayPort 1.4 and two HDMI 2.0 ports (see HDMI versus DisplayPort). There are two downstream USBs and one upstream (version 3.0). For headphones or powered speakers, a 3.5mm jack is provided. Once you’ve made your connections, a panel snaps in place to keep things tidy. A hole in the upright lets you bundle cables together neatly.

OSD Features of BenQ Mobiuz EX3210R

The EX3210R’s OSD can be controlled with a joystick under the panel or the aforementioned handheld remote. The OSD is divided into seven submenus with a myriad of picture options, lighting effects, audio modes and eye care features.

Pressing either the joystick or the center button on the remote brings up this quick menu. It shows signal status and current input, plus it lets you change the picture mode, adjust brightness and volume, and the low blue light feature. Selecting the bottom field brings up the full OSD.

The input selector includes a feature called scenarios which changes color and gamma to suit gaming or video. I found it a bit confusing, so I left it off. It’s easier to simply select the appropriate color mode for the task at hand.

The top two image presets are BenQ’s HDR emulation, HDRi, in either Game or Cinema forms. They do a good job of approximating the broader dynamic range of HDR. However, depending on the content, some highlight or shadow detail may be obscured. Display HDR is for HDR10 signals. The remaining modes are task-specific. RPG is the default, and it is reasonably accurate with a slightly cool grayscale, excellent color and a dark gamma. Custom unlocks all picture options for calibration.

BI+ is a feature that uses a bezel-mounted light sensor to adjust brightness and color temperature automatically. It works well and doesn’t make huge changes to the picture. I found it reduced eye fatigue effectively during long work sessions in my sunlit office. As with any feature like this, you should try it to see if it works for you.

In Custom mode, you can adjust a set of RGB sliders for very accurate grayscale tracking. Color is nearly spot-on whether you calibrate or not. My only complaint was the EX3210R’s gamma which departs from the standard specs. I’ll explain that further on page four.

BenQ includes a full set of eye care features in addition to BI+. If you have any degree of color blindness, the EX3210R has red and green adjustments to help compensate. Also included is a low blue light slider for reading. The LED lighting strips in the back include complete control of color with multiple effects, or you can leave it on steady if you like.

The EX3210R’s exceptional speakers can be tweaked with one of the five audio modes. Each has its own character with multiple sound stages and an emphasis on different frequency bands. My favorite for gameplay was Pop/Live. Its sound was realistic and balanced, and I could turn up the volume without introducing audible distortion.

Calibration Settings for BenQ Mobiuz EX3210R 

There are a couple of different ways to approach the BenQ Mobiuz EX3210R’s calibration, each with a compromise. If you want the best possible gamma, leave it set to the RPG picture mode. The picture is well saturated but a little dark. 

For the most accurate grayscale, use Custom with changes made to the RGB sliders. This produces superb grayscale tracking, but inaccurate gamma makes the image look flat. I used the settings below for my instrumented tests but switched between RPG and Custom during gameplay. In HDR mode, there are no picture options but the color and luminance tracking are very good.

Gaming and Hands-on with BenQ Mobiuz EX3210R

The BenQ Mobiuz EX3210R proved itself very capable in all aspects of work and entertainment. But I made a few interesting discoveries along the way.

In Windows apps, I preferred the better gamma of the RPG mode for word processing, spreadsheets and graphics editing. In the Custom calibrated mode, black levels are higher, making the picture look flat and two-dimensional. It mostly eliminates the contrast advantage of the EX3210R’s VA panel. 

RPG is very color accurate and has a dark gamma closer to 2.4. This keeps blacks truer and makes the image deeper and more lifelike though slightly dark. Text was clear and free of jaggies and edge enhancement. White backgrounds were smoothly toned and contrasted well against small fonts and icons. Photos looked realistic, and video was rendered well enough to judge the quality of the original content.

HDR in Windows has little impact, either positive nor negative. It makes the image a little brighter but does not increase contrast. There was no reason for me to use it outside of gameplay.

As it turned out, there was little reason for me to use HDR for games either. My tests showed elevated black levels and that was borne out when playing Call of Duty WWII and Doom Eternal. Both titles looked washed out and flat in HDR mode. The image was brighter for sure but with no true blacks, it lacked dimension. Color was nicely saturated but ultimately, I preferred to play all games in SDR mode.

The choice then came down to picture mode, RPG versus Custom calibrated. I tried both and settled on RPG as my favorite. Its gamma is more accurate and that manifests in its richer blacks and better perceived contrast. This, in turn, makes the colors look more saturated and vibrant. Also, when comparing SDR and HDR in the same game, I saw more detail in SDR mode.

Trying the HDRi emulation proved to be a mixed bag. In games with a lot of dark areas, it crushed detail. Though blacks were deeper, shadows were flat and fine hues were difficult to make out. Bright content was slightly enhanced by HDRi so if your game is bright, it might suit you. In my experience, SDR was the best way to play.

Video processing is by far the EX3210R’s strongest attribute. Adaptive-Sync works perfectly and in concert with blur reduction, the moving picture is super smooth. This is one of the few monitors that lets you turn on blur reduction and Adaptive-Sync together, and it’s worth buying just for that ability. And note that you can’t use blur reduction with HDR so there’s another reason to stick with SDR for everything.

Blur reduction brightens the image slightly, but I could compensate with the brightness control. This was the best way to play. I saw no change in control response, just a super smooth moving image with tons of detail. And with my test systems, maxing the frame rate was easy. For G-Sync, I used a GeForce RX 3090 and FreeSync was anchored by a Radeon RX 5700 XT. That superb motion processing made it easy to forget the EX3210R’s 93ppi pixel density. Ultra HD is great but 165fps is better.

To recap for those considering buying an EX3210R: stick to SDR, use the RPG mode and its default settings, turn on blur reduction, and set AMA (overdrive) to 1. Configured this way, it’s one of the smoothest 32-inch screens I’ve experienced.

The EX3210R comparison group is all QHD with a mix of VA and IPS panels in either 32 or 27-inch sizes. For IPS, I’ve included the Razer Raptor 27, Monoprice’s 42892 and Acer’s XB273-NV. In the 32-inch format is the Corsair 32QHD165 and Pixio PXC327. Speeds range from 165 to 180 Hz.

Pixel Response and Input Lag

Click here to read up on our pixel response and input lag testing procedures.

You won’t find much visual difference between 165, 170 and 180 Hz. In this test, all monitors draw a full white screen in six milliseconds, except for the Pixio, which takes eight. I’ve observed that even a one millisecond difference in this test makes an impact on motion resolution both in test patterns and in actual content. The EX3210R is on par for that metric.

In the total lag test, the BenQ is slightly behind the others. You won’t perceive a difference in control response between the bottom three screens but the Razer and Monoprice monitors feel a bit snappier. To a casual player like me, it’s not enough to distract, but more skilled gamers than I will prefer the faster displays. The EX3210R worked well for my gameplay and never faltered in fast-paced action sequences.

Viewing Angles

The EX3210R’s VA panel looks better off-axis than most though it will never be taken for an IPS monitor. Light falloff to the sides is minimal at just 20%. But a color shift in the middle brightness steps can clearly be seen. Interestingly, the same thing happens in the vertical plane. Detail remains well rendered, but you’ll enjoy this BenQ best when sitting in the center seat.

Screen Uniformity

To learn how we measure screen uniformity, click here.

The EX3210R manages to crack the 10% threshold in the uniformity test. That means there are no visible hotspots, bleed or glow in this sample. Other EX3210Rs may exhibit different results, but this one looked perfectly uniform in a completely dark room when displaying a full-screen black pattern.

To read about our monitor tests in-depth, please check out Display Testing Explained: How We Test PC Monitors. We cover brightness and contrast testing on page two.

Uncalibrated – Maximum Backlight Level

BenQ rates the EX3210R at 300 nits in SDR mode, but my sample came up slightly short of that mark with 274 nits. That’s close enough that it will be difficult to tell the difference in a side-by-side test. A panel this large doesn’t need more than 200 nits peak to be bright enough unless you’re in a room that receives a lot of sunlight. The EX3210R provides enough output for nearly any environment.

Black levels are low, though not as low as some other VA screens like the PXC327. But the resulting contrast is still around double that of an IPS monitor. That’s a difference that can easily be seen. The EX3210R provides plenty of deep blacks, good shadow detail and a picture that pops in its default RPG picture mode.

After Calibration to 200 nits

Calibration improves the EX3210R’s contrast slightly; it is now just over 2,000:1. While it is visually better than the other screens, it isn’t quite as good as the Pixio with a 3,421.6:1 ratio. However, it definitely has a greater dynamic range than the IPS screens.

The ANSI test reveals good screen uniformity and good quality control. 1,725.8:1 means content will appear sharp and detailed. And it will look sharper than a 32-inch IPS monitor in QHD resolution. This is very good performance.

For the color tests, I measured the EX3210R’s default RPG mode, then tried the other modes and input scenarios before calibrating the Custom preset. As you’ll see, there are a few compromises with any approach to image adjustment on this screen.

Grayscale and Gamma Tracking

Our grayscale and gamma tests use Calman calibration software from Portrait Displays. We describe our grayscale and gamma tests in detail here.

It is completely acceptable to use the EX3210R without calibration in its RPG picture mode. Grayscale is a tad warm on the chart, but the errors aren’t visible in test patterns or real-world material. Gamma tracking is unusual though. The trace runs near the 2.4 line, then takes a sharp turn upwards at the 90% step. This means that the luminance level is too dark. Some highlight details look muted but are offset by the 100% brightness step, which is at the correct value. The picture is slightly muted in general, though this can be offset by turning up the brightness slider a bit.

Calibration takes grayscale tracking to the reference level but changes the gamma tracking. Now, shadow detail is more visible, but dark areas of the image aren’t as deep. This is good for gaming if you want to see shadow areas better, but it makes the picture a little flat. The compromise is a choice between perfect grayscale or less erroneous gamma.

If you want an accurate sRGB mode, the EX3210R provides one. Its grayscale tracking is visually perfect, and gamma is just a tiny bit light with shadow areas that look slightly gray. While most users will prefer to stick with the wide color gamut, this monitor’s sRGB mode has excellent gamut accuracy.

Comparisons

The EX3210R clearly does not need calibration based on its excellent default grayscale score of 2.52dE. It’s enough to put it above all the screens except the Monoprice, which is only slightly better. Once calibrated, it slips to third place, but every panel in the group has superb accuracy after adjustment. There are no visual differences in this test between any of the subjects.

By the numbers, the EX3210R’s gamma test results are poor. The range of values is very wide at 0.97 and the average value is 5.45% off the 2.2 spec. This appears to be a choice on BenQ’s part to create a certain look to the image that isn’t necessarily to standard.

Color Gamut Accuracy

Our color gamut and volume testing use Portrait Displays’ Calman software. For details on our color gamut testing and volume calculations, click here.

If you choose RPG, Custom (calibrated) or sRGB, the EX3210R will reward you with spot-on color gamut tracking. Out of the box, there is slight over-saturation in red and the other colors are on target. Green comes up a little short as most wide gamut screens do. But the inner targets are correct. It manages to render around 90% of the green primary.

With calibration, the average error goes up a tiny bit, but this cannot be seen with the naked eye. Red saturation targets are now exactly where they should be, and green tracks more evenly. The sRGB mode is the EX3210R’s most accurate preset with near-perfect color gamut results. If you’re a purist, this is the best choice for SDR content. If you just want lots of color, RPG is the way to go.

Comparisons

It can be said that none of the monitors have visible color errors. Even though the EX3210R comes in last, it is still visually free of issues. All the screens boast excellent color accuracy. There is nothing to complain about here.

In the gamut volume test, the EX3210R is average compared to other DCI-P3 native screens. The Corsair is a definite over-achiever, while the Razer and Monoprice both crack the 90% threshold. At 88.43%, the BenQ is very colorful and clearly more vivid than an sRGB screen. With its excellent sRGB mode, it covers almost all of that gamut as well.

The EX3210R switches to its Display HDR picture mode when it senses an HDR10 signal. It is also possible to emulate HDR with SDR content by using the HDRi feature, easily accessed by a button on the front bezel or with the remote. I tested Display HDR with a correctly formatted HDR10 signal to record the results shown below.

Our HDR benchmarking uses Portrait Displays’ Calman software. To learn about our HDR testing, see our breakdown of how we test PC monitors.

HDR Brightness and Contrast

The EX3210R outputs plenty of light in HDR mode with just over 404 nits peak, earning its VESA DisplayHDR 400 certification. None of the other monitors stand out as significantly brighter or less bright than the BenQ.

The key to good HDR is black levels and there, some sort of dynamic contrast feature is a must. Not all screens have it though, and the EX3210R is one of those. Its black levels are a little elevated, which reduces its HDR contrast to just 1,468.8:1. While HDR looks OK here, it doesn’t compete with the Pixio, Razer or Acer screens. I tested the HDRi modes too and found they were slightly better with ratios of around 1,900:1. But they are less color accurate than Display HDR.

Grayscale, EOTF and Color

These two charts are from the EX3210R’s Display HDR mode using an HDR10 signal. Grayscale tracking is mostly error-free except for the darkest steps, which look slightly blue. This does not impact real-world content in any meaningful way. EOTF luminance tracking is solid except for the 0-15% steps, which are too light. This results in shadow areas that are detailed but more a dark gray than the black they should be. The EX3210R needs a bit of factory tuning to improve its HDR black levels and contrast.

HDR color is very good with just a bit of over-saturation in red and blue. The outer targets are met except for green which is a little under. This is typical of wide gamut screens in general. Hue targets are spot-on, with no deviation seen in any color. The EX3210R has above-average HDR color accuracy.

The ideal gaming monitor will deliver both a high-quality image and smooth video processing with quick response and low control lag. Throwing in good build quality never hurts. Once you find those things, value becomes key. Balancing the price/performance ratio is important. Though there are plenty of Ultra HD screens available, they top out at 144 Hz and require a lot of video card horsepower to even hit 100fps. A QHD monitor can easily achieve 120fps with a mid-priced graphics board and deliver a smooth 165fps if you have premium hardware.

The BenQ Mobiuz EX3210R delivers that gaming performance by being one of the few monitors to allow blur reduction and Adaptive-Sync to operate at the same time. That ability alone is reason enough to put it on your shortlist. It also sets itself apart with a tight 1000R curvature. No other 16:9 32-inch screen wraps as tightly around the player’s viewpoint.

With a 165 Hz refresh rate, the EX3210R is on par with the competition. Its total control lag is a couple of milliseconds behind the other monitors I compared it to, but in gameplay, that was not a factor. What stood out most was its superior motion resolution. The ability to run blur reduction and Adaptive-Sync together is a value that cannot be overstated. The only other way to achieve this smoothness is with frame rates over 200 fps.

The picture anomalies I noted are relatively minor. Though BenQ has chosen to engineer the EX3210R’s gamma off the normal spec, it only makes the picture a little darker. It’s mitigated by the panel’s very accurate color and no need for calibration in the RPG color mode. And if you want to use sRGB, that mode is superb, good enough for color-critical tasks.

The EX3210R also falls a bit short with HDR content. I found contrast to be lower thanks to elevated black levels. Though HDR color is excellent, it doesn’t provide the extra pop normally associated with this material. During my tests and gameplay, I treated the EX3210R as an SDR-only screen.

Ultimately, I had to reward this monitor for its superior video processing. Though there are a few image issues, they weren’t enough to offset the high motion resolution and exceptional gaming performance I experienced. For that reason, the BenQ Mobiuz EX3210R is definitely worth serious consideration for pairing with medium-to-high budget gaming rigs.

Creating a custom interface is one of the most exciting aspects of creating a retro gaming system with the Raspberry Pi. Tons of themes and original UIs have emerged over the years, but Neil, from YouTube channel RMC - The Cave, has taken things to the next level by creating a retro game shop replica as part of his retro games museum that functions as a front end for his emulation platform.

Instead of selecting a game from a menu on the screen, users choose a game from the physical store shelves and scan it using a barcode scanner. Once a game is selected, it will automatically load for the user to play. The glue that makes all of this work, is a Raspberry Pi 3B and a little Linux magic.

Neil uses a simple USB barcode scanner connected to a Raspberry Pi 3B. The Pi works in tandem with a MiSTer Multisystem, a retro gaming emulation platform, outputting video to a Sony 14-inch Trinitron TV.

The retro gaming emulation is handled entirely by the MiSTer Multisystem. The Pi comes in primarily to manage the barcode scanning system. Neil breaks down in greater detail how he configures the Pi to trigger game changes on the Multisystem platform in the original demo video. Put simply, the Pi communicates with the MiSTer, sending commands and game ROMS over a secure network connection. As Neil confesses, this is achievable for 16-bit era machines, but 32-bit era, such as the original Playstation and Sega Saturn will be harder given the larger CD ROM images.

It’s one of the coolest UIs we’ve ever seen in a Raspberry Pi project. To get a closer look at this system in action, check out the official RMC - The Cave channel over at YouTube and be sure to follow Neil for more fabulous creations.

Who remembers the Sol-20? Us neither, but it was an important milestone on the path to where we, and our computers, are today. Without the Sol-20 the home computer world would be very different. This important point in home computer history is an excellent choice, then, for a retro computer reproduction project such as that carried out by Michael Gardi (and highlighted by Hackaday) using a Raspberry Pi in place of the Intel 8080 at the original computer’s heart.

The first fully assembled microcomputer with both a built-in keyboard and a TV output, the Sol-20 had the misfortune to be released in 1976, a year before Apple, Commodore and Tandy came and stomped all over the market with the Apple II, Pet and TRS-80. Initially sold in three versions - a motherboard kit; the Sol-10 added a case, keyboard and power supply, but came with no expansion slots; and the Sol-20 beefed up that power supply and added five S-100 bus slots (the Sol-20 would be by far the most popular model). The computer stayed in production until 1979 and would sell around 12,000 units, making them incredibly rare today. For contrast, total Apple II sales would hit around six million, including a million in 1983 alone.

For the 2021 version, having an authentic-looking case was a priority. The distinctive blue original was made of sheet metal with wooden sides, but Gardi reached for his 3D printer rather than his cutting torch to make the build more accessible to others. The sides are made from walnut, a material slightly befitting the aesthetic of the time.

Gardi also made a matching display for the Sol-20, again 3D printed and embellished with walnut, it utilises a 4:3 LCD panel and connects to the Pi via an HDMI cable.

The keyboard is a replica of the original in layout, but sits on modern Cherry MX switches. The board comes as a kit from osiweb.org. The brains of the operation is a Raspberry Pi 4 running an 8080 emulator written in Python and forked from one available on GitHub. The virtual CPU has 64kb of memory (most systems shipped with 8 or 16kb) and supports storage on virtual cassette tapes. There's a lot - and we mean a lot - more detail on Gardi’s Hackaday.io project site, including his use of an Arduino as a keyboard interface, the creation of an RS232 port, and his success ‘drawing’ the Sol-20 logo on a rectangle of acrylic using his 3D printer (see best 3D printers).

According to @RPCS3 on Twitter, Intel's Alder Lake CPUs are some of the best CPUs you can buy for PS3 emulation right now. In a test showcasing God of War: Ascension, running on the Open-Sourced Playstation 3 Emulator, the Core i9-12900K is around 15% faster than the previous-gen Core i9-11900K. Both chips clocked in at 5.2 GHz.

To make the comparisons as even as possible, RPCS3 disabled all the E-cores on the 12900K and enabled the AVX-512 instructions set, which is an instruction set the Open-Sourced Playstation 3 Emulator can leverage. Both chips also had HyperThreading disabled and were overclocked to 5.2 GHz.

With these changes in mind, the 11900K was able to output 68 FPS in Gold of War: Ascension, meanwhile the 12900K increases that frame rate to 78FPS, a 10FPS difference or 14% difference in performance.

Unfortunately, @RPCS3 does not demonstrate emulation performance on the 12900K with the E cores enabled and AVX-512 disabled. This would be very interesting to know since it is the default Alder Lake configuration. It would also be interesting to see how much of a difference AVX-512 really makes to this PS3 emulator.

However, in another Twitter post, @RPCS3 notes that due to AVX-512 support, disabling the E cores does provide Alder Lake chips with increased performance in its PS3 emulation utility. Keeping the E cores enabled with AVX-512 disabled will leave "a lot of performance on the table."

So it appears the Open-Sourced Playstation 3 Emulator does take advantage of AVX-512 enough to make a big difference to gaming performance. For anyone who does a lot of PS3 emulation, it would be best to ensure AVX-512 support is on despite losing the extra multi-threaded performance of the efficiency cores.

Microsoft announced that Windows 10 PCs running on Qualcomm Snapdragon Arm SoCs would receive x64 emulation support in October 2020, and Windows Insider builds soon arrived. Today, however, Microsoft just poured cold water all over those aspirations, confirming that x64 emulation will no longer be offered in future Windows 10 Insider Preview builds (or release builds).

“x64 emulation for Windows is now generally available in Windows 11,” said Microsoft in a blog post first noticed by Paul Thurrott. “For those interested in experiencing this, a PC running Windows 11 on Arm is required.”

For those that need a refresher, x64 emulation allows Windows 10 on Arm devices to run apps designed for x86-64 processors from Intel and AMD. There’s a performance hit with emulation, but it’s worth it for many users to have access to a broader library of apps, including popular ones like Adobe’s Creative Cloud suite that requires an x86-64 processor to run. 

Microsoft’s latest snub is disappointing news for folks testing x64 emulation with Windows 10 on Arm. It’s even more of a bummer for those that have no interest in upgrading to Windows 11. However, Microsoft is simply dangling a carrot in front of developers and everyday users to upgrade to Windows 11. 

There’s no technical reason why Windows 10 should be left behind. But Microsoft has a greater incentive to push as many people to Windows 11 as soon as possible, and this is one way to accelerate that process for users with Arm-based systems. So, if you currently have a device like the Samsung Galaxy Book S (Snapdragon 8cx) or Microsoft Surface Pro X (Microsoft SQ1/SQ2), upgrading to Windows 11 is the only way to continue with x64 emulation.

We should note that standard 32-bit x86 emulation is still supported with Windows 10 on Arm and will be for the near future. “Microsoft is committed to supporting customers on Windows 10 on Arm through October 14, 2025,” the company added in its statement.

Raspberry Pi computers, even the diminutive Raspberry Pi Zero, have long been used as emulators. Thanks to software like RetroPie (see how to install RetroPie on a Raspberry Pi), you can run games and apps from old computers dating back to the 1970s and 80s.

Unlike other Raspberry Pi SBCs, which run Linux on chips that are at least 1 GHz (often 2.5 GHz), the Raspberry Pi Pico is a relatively simple microcontroller that has no OS on its 133 MHz dual-core RP2040 processor. Nevertheless, since the Pico came out in January, we've seen it used for some impressive emulation projects, including one which turns the $4 board into a Nintendo NES. 

Now, Twitter user @bobricius has developed a custom PCB which attaches to a Raspberry Pi Pico and turns it into a ZX Spectrum / Commodore 64, complete with a built-in game pad.  A project called M.CU.M.E (Multi CompUter Machine Emulator) is the heart of this build, and it is used as the software layer for running the old applications.

The SBC features both a controller and a built-in LCD display. The controller is wired directly to the Raspberry Pi Pico and has a separate piece of buttons for movement, and a few to control the in-game happenings.

In addition to having an embedded display, you can connect this entire setup to an external monitor, which the project aims to power by the addition of a VGA connector. As demonstrated below, you can see the project outputting video to the monitor and actually playing some of the games.

While this doesn't represent a commercial project that will make it into production, it is just a fun and creative way to use the Raspberry Pi Pico platform to revive the 80s gaming experience and get back to where it all started.

Nothing says that a new console generation is here quite like the old console gen getting working emulators. And despite the PS5 still being hard to come by, the PS4’s emulation day has come. Spine, a closed source PS4 emulator for Linux that’s been privately in the works since 2019 just made its first full public release earlier this month, complete with a new compatibility list featuring hundreds of games.

There are a few caveats, though. PS4 emulation is still in its early days, and the games that currently work with emulation reflect that. While Spinedev’s pushed far beyond what they had working in Spine’s 2019 demo, most of what the current compatibility list labels as working "ingame" (one word) are smaller 2D titles that already have their own proper PC releases. In other words, don’t expect to be playing God of War or Spider-Man: Miles Morales on your PC any time soon. And just because a game technically runs doesn’t mean it works flawlessly. For instance, you can play Sonic Mania in Spine, but the color palette looks trippy even for Sega’s blue blur. 

Spine’s also limited to Linux for now, there’s no GUI to speak of and you’ll have to acquire your own firmware and game files. That last part’s especially tricky, since you’ll probably need to mod your own PS4 to get your hands on the data you need. (Which, of course, comes with the usual legal gray areas.)

But even in this nascent state, Spine’s far ahead of other PS4 emulator projects like Orbital and isn’t a likely scam like PCSX4. Watch out for that last one, by the way, since it’s the first google result when you search for “PS4 Emulator.” It’s named after a popular emulator for PS1 and PS2, but the site in its current state just exists to serve ads and get you to fill out surveys.

In truth, Spine right now is mostly just be a curio, but it's a promising one. Unless you want to play 2D games like Dead Cells, which you should probably just buy the proper PC ports for, you won’t get much practical use out of it. But it’s a positive sign of things to come. Emulation might be a tricky topic, but given the current state of digital stores and rights management, there’s an argument to be made that it’s vital to game preservation. Nobody's really selling Wonderswan games new anymore, you know? Just don’t expect to skirt around shelling out the money for AAA Sony exclusives quite yet.

If you want to play games exclusively designed for Sony's PlayStation 3 on your pC, there is the RPCS3 emulator for that. And now this emulator supports AMD's FidelityFX Super Resolution (AMD FSR) upscaling technology. You can now play a PS3-exclusive Final Fantasy on a Windows-based PC with enhanced quality, it appears. 

To do so, you need to use appropriate launchers like Magpie or Valve’s Wine implementation for Proton, reports VideoCardz. In general, this is not surprising as the technology seems to be heavily based on a well-known algorithm.  

RPCS3 says that 62% of PS3 games are 'playable' with its emulator. There are also games that do not work well though, which is why there is a compatibility list. 

Sony's PlayStation 3 is perhaps one of the most controversial consoles in terms of hardware. The game console is based on the Cell processor co-developed with IBM featuring one high-performance core as well as eight cores mostly focused on floating point processing. Being one of the first hybrid microprocessors, it received a lackluster welcome from software makers. This certainly makes it harder. Meanwhile, on the graphics side of things Sony's PS3 featured an Nvidia Tesla-based GPU, which is an architecture from 2005. 

Porting a game designed exclusively for Sony's PS3 to another platform is both time consuming and counterproductive for game developers. This is where emulators come into play. To try this for yourself, visit the RPSC3 website.

Usually, we use PCs to emulate other systems, be it retro computers or Android apps. Using something else to emulate a PC is a little different, especially when it’s the original IBM PC, and it’s running on a tiny microcontroller board like this one from Fabrizio Di Vittorio and spotted by Hackaday. It does make us wonder, if the $4 Raspberry Pi Pico could be used in a similar manner? It too can be used to emulate retro hardware.

The board in question is an ESP32, in this case an ESP 32 development board. They’re available in RISC-V and Xtensa LX7 versions, and judging from the clock speed visible in one of the videos, it’s the latter we’re dealing with here. Di Vittorio’s oddly silent video takes you through the steps of compiling the code from its repository on an emulated board in Arduino software. His next, piano accompanied, video shows the emulator running on an actual board, booting FreeDOS, and then opening GW Basic 3. 

The original IBM PC, launched in August 1981, boasted a 4.77MHz Intel 8088 CPU and up to 640Kb of RAM. It could run PC-DOS or CP/M-86, and run BASIC and Pascal-derived programming languages. It used 5.25in floppy disks, with optional tape and hard drives.

The ESP32 emulator does extremely well, even managing to run Flight Simulator (no, not that Flight Simulator) and a lovely monochrome Windows 3.0 (which would run on an 8088 but required a staggering 1Mb of RAM) in which we see Excel, Word and PaintBrush being opened and used. 

Di Vittorio has form in this area, having previously written the useful FabGL library for writing games on the ESP32.

The Apple II released in June 1977 was one of the first successful mass-produced computers and Apple’s first personal computer aimed squarely at the consumer market. The hardware was designed primarily by Steve Wozniak and the case by Steve Jobs, who we both know as the founders of Apple. In 1977, there were three machines vying for attention and inclusion in our lives: the Apple II, the Commodore PET and the Tandy TRS-80.  In the USA, the Apple II was adopted and loved by a generation of coders who took their first steps with this great machine.

Emulating an Apple II

The cost of original Apple II hardware has skyrocketed and so to take our first steps with this great machine, we look to emulation via microm8.

1. Download and install microm8 for your operating system.

2. Open the microm8 executable. On first boot it will need to update, so be patient.

Once it has finished updating, microm8 will restart and present a rather retro 3D menu (see above).

3. Select Applesoft BASIC to open the BASIC interpreter.

BASIC is a general purpose high level language and the original version was designed by John G. Kemeny and Thomas E. Kurtz and was released at Dartmouth College in 1964. In basic terms (no pun intended), BASIC is a human readable language that uses words common in the English language. 

BASIC is the Python of the 1970s and 80s. Machines such as the Apple II were designed to boot straight into BASIC and from there we can write code and basic file operations.

Creating a Number Guessing Game

For our BASIC project we shall create a number guessing game. we have ten chances to guess the correct number before the game ends. If we guess too high, the game will tell us so, the same is true if we guess too low.

1. Line 10, create a variable, N and inside the variable store a random integer between 0 and 50.

10 N = INT(50*RND(1))

2. Lines 20 and 30, write two instructions to the player. The first informs them that they have ten attempts to guess the number, and then it asks for their guess.

20 PRINT "YOU HAVE 10 TRIES TO GUESS THE CORRECT NUMBER"30 PRINT "WHAT IS YOUR GUESS?"

3. Line 40. Create a for loop that will iterate ten times.

40 FOR C = 1 TO 10

4. Line 50. Capture the user's answer into a variable, G.

50 INPUT G

5. Lines 60 to 80. Create three conditional tests. Each test will check the value of the user's answer, G, with the randomly generated answer. If the answer is too high or low then a message is printed to the user. If their guess matches the random value, the code jumps out of the for loop.

60 IF G > N THEN PRINT "TOO HIGH";70 IF G < N THEN PRINT "TOO LOW";80 IF G = N THEN GOTO 130

6. Line 90, check the value of the variable C, which counts from 1 to 10. If the value of C is not 10, then print “TRY AGAIN” and then for line 100 iterate the for loop by one and the code will loop back to line 50.

90 IF C<>10 THEN PRINT " TRY AGAIN"100 NEXT C

7. Line 110, create a “bad ending” for the game. If the player doesn’t guess the number then lines 110 and 120 will be our game over screen.

110 PRINT " I'M SORRY YOU FAILED...GAME OVER!"120 END

8. Lines 130 and 140 are the “good ending” of the game, activated when the player wins the game.

130 PRINT "YOU GUESSED CORRECTLY"140 END

To run the game, type RUN and try to guess the correct number.

Playing a Game on the Apple II 

The Apple II had many great games, some of which were ports from arcades and other consoles while others were made directly for the Apple II. Luckily for us microM8 comes with an extensive catalogue of games builtin.

1. From the microM8 menu screen press B to open the disk catalog.

2. In the Disk catalog look for “appleii” and double left mouse click to open.

3. Click on the “disk images” folder.

4. Click on Games and then select a letter from the list to show games starting with that letter. Select your game and enjoy!

This story originally appeared in an issue of Linux Format Magazine 

Jamhamster is a maker with an affinity for retro hardware, and we're right there with him! For this project, he managed to fit a Raspberry Pi Zero inside of a custom cassette tape to emulate an old ZX Spectrum computer.

The cassette features artwork boasting "ZX Spectrum" in the title box. This isn't an original cassette; the label was custom-designed just for this project. Inside is an aluminum plate that acts as a giant heatsink for the Pi Zero. 

Fitting the Pi Zero inside wasn't easy as the width of the Pi and clearance between the reels and tape bottom don't match. According to Jamhamster, four GPIO pins had to be sacrificed. The final rig includes plenty of external ports though and even a safe shutdown button.

For audio, Jamhaster created a headphone socket and wired to the Pi Zero. The project also has a USB hub with two ports accessible from the top.

The best Raspberry Pi projects are the ones you can recreate. Check out the original thread shared by Jamhamster on Reddit to see how this project works in greater detail.

The range of Raspberry Pi Pico accessories keeps growing, and the latest is from Olimex. In a render teased via Twitter, Olimex appears to be working on their own breakout board with a focus on emulation, and it looks like they have crammed in everything we could need for a dose of retro computing.

Olimex, a well-known name in the maker community, has teased its own breakout board for the Raspberry Pi Pico. Its focus is on designing a board to accommodate retro emulation. Spurred on by Graham Sanderson's BBC Micro computer emulator, Olimex confirmed that this board would be their first board in the Pico range.

The RP2040-PICO-PC is, as the name cryptically suggests, a 'PC' that uses the Raspberry Pi Pico as the heart of the board. Looking at the teaser image, it appears that Olimex is looking to use Pico boards directly with the RP2040-PICO-PC. But in a recent tweet, we saw that Olimex had received a sample of bare RP2040 chips intended for community members to develop their own RP2040 devices. Could we see an RP2040 at the heart of the board?

Back to the teaser. In the image, we can see series of two male headers for the Raspberry Pi Pico. Whether they are intended to hold the Pico via solder or friction fit remains to be seen. There is a chance that they could also be breakouts for the GPIO, and the RP2040 is mounted on the underside of the board. Right now, the render is all we have to go on.

The RP2040-PICO-PC has a micro USB port on the right side of the board, and next to there is a two-pin JST connector, most likely for a Lipo battery connection. There's also a micro SD card connector on the bottom left of the board, most likely accessible via an SPI interface. Along the top edge of the board, we see a DVI video output, a USB host connector for a keyboard, and a 3.5mm audio jack. A 10-pin connector is right at the top of the board — this is a UEXT (Universal EXTension) connector that breaks out I2C, SPI, and RS232 serial. The UEXT connector is intended for use with UEXT modules, such as an LCD screen and sensors that are available separately.

How much and when can we buy one? Well, for now, those questions will have to remain unanswered, but we can say that the RP2040-PICO-PC could be a fun project for retro enthusiasts.