Z386: An Open-Source 80386 Built Around Original Microcode

May 25, 2026 by 2 Comments

There are many ways you can implement an Intel i386 CPU on an FPGA, with the use of original microcode probably being one of the most interesting approaches. This is what [nand2mario]’s z386 project does, with a recent blog post summarizing development on this FPGA project so far.

This project is similar to the previously developed z8086 project, which as one may guess does something similar, except for the Intel 8086 CPU. By executing the original microcode you’re basically guaranteeing close compatibility with the original hardware, though of course the sheer scale of this microcode between an 8086 and 80386 is quite different.

There’s a much larger instruction set with a correspondingly much more complicated internal state to keep track of, including all those newfangled features like memory management, paging and register debugging, as well extensions to protected mode that began with the i286.

Currently z386 runs on a number of FPGAs, including the Altera Cyclone V and Gowin GW5A, with performance equivalent to a ~70 MHz i386 albeit with slightly worse cycle efficiency, some of which could be due to the limited 16 kB cache compared to the 32+ kB cache in the fastest i386 CPUs. Either way, it’s more than enough to run all kinds of software, including games like DOOM.

Important to note is that the goal here isn’t to be more performant than cores such as for example ao486, but more as an archaeological reconstruction of the original hardware and its interaction with said microcode.

Top image: line-up of Intel 286, 386 and 486 CPUs. (Credit: Sgroey, Wikimedia)

Lost Version Of Amiga Unix Suddenly Reappears

May 25, 2026 by 3 Comments

Some of you may know there’s a version of UNIX for the Commodore Amiga, aptly called Amiga Unix or AMIX. There is an almost complete record of versions from 1.0 to 2.03, but 2.02 was lost media–until [Forgotten Computer] found it on an old Amiga.

It starts with an auction held for the 40 year anniversary of the Free Software Foundation where, by just one second, the highest bidder was too late. What do you do first with an artifact as valuable as an old FSF computer? You image the hard drive. Then you make several copies, including on different computers–after all, you wouldn’t want to lose the data on it. Preservation secured, the natural next thing is to boot it–and that’s when we see the magic 2.02c version number.
According to thorough digging by [Forgotten Computer], this version was–until now–lost.

In the video after the break, [Forgotten Computer] goes over what Amiga Unix is, the discovery process, and explores what’s on the disk–including FSF staples like GCC, G++ and core utilities like GNU less.
Continue reading “Lost Version Of Amiga Unix Suddenly Reappears” →

3D Printing Space Cadet Pinball Into The Real World

May 25, 2026 by 6 Comments

Unless you’ve managed to avoid touching a Windows computer until after the Windows XP era, it’s pretty good odds you’ve played Space Cadet Pinball. Some of you may have even paid for the Mac port of Full Tilt! Pinball, the actual game the Windows freebee was supposed to demo. Unofficial ports exist for Linux as well, which means the one place nobody has ever played the game is, ironically, on a pinball table. [CNCDan]aims to change that in a video embedded below.

Ironically given [CNCDan]’s name, the parts he starts with — the two sorts of pop bumpers, the drop targets, slingshots, and delayed-drop hole– are all largely 3D-printed. While some of these parts are available commercially, it turns out that the scaling of the virtual pinball machine doesn’t match anything on offer, and rather than compromise [CNCDan] decided to do it himself, an attitude we absolutely respect.

All that’s left are the flippers– his first prototype wasn’t powerful enough–and a couple minor mechanisms before building the table. To do that, he’ll need high-resolution art worth printing. Not surprisingly, a game dating from 1995 doesn’t have high resolution assets available with which to do that. That kind of creativity isn’t in [CNCDan]’s wheelhouse, so if it is in yours and you want to collaborate, or know someone who does, you can reach [CNCDan] at his YouTube page. At the very least, he can pay you in playtime.

[CNCDan] often goes beyond his namesake, like with his SteamDeck-like handheld, or his 3D printed VR headset. Still, no guesses how he’s going to build the cabinet.

Continue reading “3D Printing Space Cadet Pinball Into The Real World” →

A diagram of a neutron generator is shown in the top portion of the image, with the physical version below.

A Benchtop Neutron Generator For The Home Reactor

May 25, 2026 by 6 Comments

There are a surprising number of experiments an amateur nuclear physicist can perform, from making a Geiger counter to fusing hydrogen atoms in a fusor. One project which we haven’t seen before is a neutron generator, such as the benchtop neutron generator made by [Rapp Instruments] (translated).

This particular generator takes a feedstock of pure deuterium, which it ionizes and accelerates into a titanium target. The first deuterium nuclei to hit the target react with it to form titanium deuteride, immobilizing them until more ions strike them and they undergo nuclear fusion. The fusion reaction mostly forms helium-4, but sometimes forms helium-3 and a free neutron, which is radiated away. The radiated neutrons are slowed down by a block of high-density polyethylene, and a portion of them strike a silver or indium foil wrapped around a Geiger counter tube. The neutrons activate the silver or indium, and the Geiger counter detects the resultant increase in radioactivity.

The design is a linear particle accelerator built inside an evacuated glass tube. It uses two high-voltage power supplies: a 20 kV supply which ionizes the deuterium gas fed into the tube, and a 100 kV supply which accelerates ions emitted from the source into the target. The target itself is surrounded by a cup-shaped electrode to capture secondary electrons emitted during impact. To prevent arcing, the tube needs to be at a very low pressure, reached by extensive use of an oil diffusion pump.

Radioactivity measurements of the silver and indium foils showed that the generator did work; when irradiating the silver foil for five minutes, it generated 175 counts per second after the neutron source was turned off. Plotting the count rate versus time suggested that a mixture of two silver isotopes was being generated, Ag-110 and Ag-108, based on their half-lives. Irradiation of indium produced a similar exponential decay in radiation.

We recommend checking out the rest of the site; it’s a gold mine of projects, such as this mass spectrometer. For more background on neutron generators, we’ve covered their theory and some of the more common varieties.

A square red circuit board is shown on a black workbench. The circuit board houses two large chips in the upper left corner, each with a large heat sink attached.

Just How Bad Was The Intel IAPX432?

May 25, 2026 by 33 Comments

Processor design over the last few decades has moved toward RISC processors that aim to implement a few simple operations very efficiently. For a while, though, the trend was toward ever-more-complex CISC designs that let programmers implement complex behaviors using as few instructions as possible. Few processors took this approach further than the Intel iAPX432. This hyper-CISC processor was a commercial failure, largely due to its notoriously poor performance, but [MarkTheQuasiEngineer]’s benchmark suggests that this notoriety wasn’t totally deserved.

The first step before running a benchmark was to build a computer around the processor. The iAPX432 was implemented in three chips, two of which acted as the general data processor (GDP), and one of which handled input and output. [Mark] built an SBC (design and code here) that houses the two GDP chips and an FPGA for I/O. The 432 did have a well-deserved reputation for efficiently turning electricity into heat, and the original voltage regulator failed rather quickly.

The 432 was designed to use machine code which was almost a high-level language, with built-in object-oriented programming. It had over 200 operators, some of which implemented complex object-oriented operations, and a wide variety of data types, but it had no directly-accessible general-purpose registers. In addition to the lack of registers, it also had a very complex addressing system, allowing both direct and indirect addressing. For better performance, [Mark] used direct addressing.

For the benchmark, [Mark] implemented the Spigot algorithm to calculate the value of Pi. The results were somewhat surprising: calculating 2048 digits, it beat his previous retro-processor benchmarks; an Intel 8086 running the same algorithm took 2.5 times as long. Based on the results of this hand-written code, [Mark] speculates that the 432’s poor performance had more to do with poor compiler optimization than with the fundamental design.

We’ve covered some of the history of this troubled chip before. For a similarly ambitious but ill-fated Intel project, check out the history of Itanium.

Slightly Sentient D20 Might Subtly Shift Your Rolls

May 25, 2026 by 1 Comment

A twenty-sided die (d20) is a common thing in tabletop gaming, and [kati]’s slightly sentient d20 is a PCB that not only delivers random results on demand, but responds to hot and cold streaks and may even tweak the results a little to reflect its mood.

On its face the unit is a touch-sensitive PCB with twenty small charlieplexed LEDs around its perimeter, one for each die result. When activated by a touch on the center pad, the die dutifully animates a die roll and delivers a result. But something happens if the RNG (random number generator) coughs up results that are unusually lucky, or unlucky.

In addition to moods, there are reportedly other hidden features to discover.

After a streak of natural 1s, the device gets cranky. It begins to ignore the occasional activation input, and may glitch before a roll, reflecting a low mood. In addition, future rolls while in a low mood have a slight chance of being silently discarded and re-rolled into a low range (1-6), prolonging the unlucky streak. The inverse is true of a die that encounters a lucky run of natural 20s, with the die’s mood shifting to high spirits and having a slight chance of re-rolling future results into a high range (16-20).

The idea is to create (and feed) the feeling of lucky and unlucky streaks. Gamers are of course perfectly capable of projecting such feelings all on their own, which means the die acts as both mirror and amplifier of these emotions. In addition, each die acts slightly differently as a result of being imprinted with different RNG seeds, timing values, and response times which makes each one feel unique. There are reportedly other hidden features as well.

If you’d like to try making your own, keep an eye on the GitHub repository. The originals have design elements that were heavily personalized for [kati]’s gaming group, so the design files are in the process of being turned into a meaningful public release. Of course, there’s more than enough detail already to roll your own if you are so inclined.

Hacking A Video Walkie Talkie’s TXW818 MCU And Running DOOM

May 24, 2026 by 10 Comments

Recently cheapo video walkie-talkies popped up on everyone’s favorite online retailers, which naturally lured in the usual gaggle of reverse-engineering enthusiasts of cheap tat to see what’s inside these devices, as well as what more they can be made to do. Cue [Aaron Christophel] doing just that, with the typical DOOM demo as proof of concept.

Inside these cheerful little devices is a TXW818 MCU, made by TaiXin Semiconductor. It provides its own CK803 CPU core at 240 MHz with 272 kB of SRAM, as well as BLE and 2.4 GHz Wi-Fi support. For these walkie-talkies an additional 4 MB of PSRAM is provided as well as 2-4 MB of SPI Flash.

The display is a glorious 240×320 LCD, which actually fits rather well with a game like DOOM. As also explained on the GitHub project page, to build the project you simply have to fetch the CDK IDE and build the binary. After that it can be flashed with an STM32F103 ‘Blue Pill’ based board.

According to [Aaron] the SDK is rather convoluted and not that nice to work with, so it’s not a sleeper ESP32 alternative, but these cheap walkie-talkies could be nice to tinker with anyway. Other than playing games, of course, as the side buttons aren’t very conducive to gaming, and the limited Flash space required compressing the WAD game file.

Continue reading “Hacking A Video Walkie Talkie’s TXW818 MCU And Running DOOM“ →