Retrocomputing: Simulacrum Or The Real Deal?

December 20, 2025 by Elliot Williams 6 Comments

The holidays are rapidly approaching, and you probably already have a topic or two to argue with your family about. But what about with your hacker friends? We came upon an old favorite the other day: whether it “counts” as retrocomputing if you’re running a simulated version of the system or if it “needs” to run on old iron.

This lovely C64esque laptop sparked the controversy. It’s an absolute looker, with a custom keyboard and a retro-reimagining-period-correct flaptop design, but the beauty is only skin deep: the guts are a Raspberry Pi 5 running VICE. An emulator! Horrors!

We’ll admit to being entirely torn. There’s something about the old computers that’s very nice to lay hands on, and we just don’t get the same feels from an emulator running on our desktop. But a physical reproduction like with many of the modern C64 recreations, or [Oscar Vermeulen]’s PiDP-8/I really floats our boat in a way that an in-the-browser emulation experience simply doesn’t.

Another example was the Voja 4, the Supercon 2022 badge based on a CPU that never existed. It’s not literally retro, because [Voja Antonics] designed it during the COVID quarantines, so there’s no “old iron” at all. Worse, it’s emulated; the whole thing exists as a virtual machine inside the onboard PIC.

But we’d argue that this badge brought more people something very much like the authentic PDP-8 experience, or whatever. We saw people teaching themselves to do something functional in an imaginary 4-bit machine language over a weekend, and we know folks who’ve kept at it in the intervening years. Part of the appeal was that it reflected nearly everything about the machine state in myriad blinking lights. Or rather, it reflected the VM running on the PIC, because remember, it’s all just a trick.

So we’ll fittingly close this newsletter with a holiday message of peace to the two retrocomputing camps: Maybe you’re both right. Maybe the physical device and its human interfaces do matter – emulation sucks – but maybe it’s not entirely relevant what’s on the inside of the box if the outside is convincing enough. After all, if we hadn’t done [Kevin Noki] dirty by showing the insides of his C64 laptop, maybe nobody would ever have known.

Testing 8 Solder Flux Pastes After Flux Killed A GeForce2 GTS

December 20, 2025 by Maya Posch 5 Comments

Riesba NC-559-ASM flux being applied. (Credit: Bits und Bolts, YouTube)

Flux is one of those things that you cannot really use too much of during soldering, as it is essential for cleaning the surface and keeping oxygen out, but as [Bits und Bolts] recently found, not all flux is made the same. After ordering the same fake Amtech flux from the same AliExpress store, he found that the latest batch didn’t work quite the same, resulting in a Geforce 2 GTS chip getting cooked while trying to reball the chip with uncooperative flux.

Although it’s easy to put this down to a ‘skill issue’, the subsequent test of eight different flux pastes ordered from both AliExpress and Amazon, including — presumably genuine — Mechanic flux pastes with reballing a section of a BGA chip, showed quite different flux characteristics, as you can see in the video below. Although all of these are fairly tacky flux pastes, with some, the solder balls snapped easily into place and gained a nice sheen afterwards, while others formed bridges and left a pockmarked surface that’s indicative of oxygen getting past the flux barrier.

Not all flux pastes are made the same, which also translates into how easy the flux remnants are to clean up. So-called ‘no clean’ flux pastes are popular, which take little more than some IPA to do the cleaning, rather than specialized PCB cleaners as with the used Mechanic flux. Although the results of these findings are up for debate, it can probably be said that ordering clearly faked brand flux paste is a terrible idea. While the top runner brand Riesba probably doesn’t ring any bells, it might be just a Chinese brand name that doesn’t have a Western presence.

As always, caveat emptor, and be sure to read those product datasheets. If your flux product doesn’t come with a datasheet, that would be your first major red flag. Why do we need flux? Find out.

Continue reading “Testing 8 Solder Flux Pastes After Flux Killed A GeForce2 GTS” →

Linux On A Floppy: Still (Just About) Possible

December 20, 2025 by Jenny List 7 Comments

Back in the early days of Linux, there were multiple floppy disk distributions. They made handy rescue or tinkering environments, and they packed in a surprising amount of useful stuff. But a version 1.x kernel was not large in today’s context, so how does a floppy Linux fare in 2025? [Action Retro] is here to find out.

Following a guide from GitHub in the video below the break, he’s able to get a modern version 6.14 kernel compiled with minimal options, as well as just enough BusyBox to be useful. It boots on a gloriously minimalist 486 setup, and he spends a while trying to refine and add to it, but it’s evident from the errors he finds along the way that managing dependencies in such a small space is challenging. Even the floppy itself is problematic, as both the drive and the media are now long in the tooth; it takes him a while to find one that works. He promises us more in a future episode, but it’s clear this is more of an exercise in pushing the envelope than it is in making a useful distro. Floppy Linux was fun back in 1997, but we can tell it’s more of a curiosity in 2025.

Linux on a floppy has made it to these pages every few years during most of Hackaday’s existence, but perhaps instead of pointing you in that direction, it’s time to toss a wreath into the sea of abandonware with a reminder that the floppy drivers in Linux are now orphaned.

Continue reading “Linux On A Floppy: Still (Just About) Possible” →

Reverse-Engineering The Intel 8087 Stack Circuitry

December 19, 2025 by Maya Posch 2 Comments

Although something that’s taken for granted these days, the ability to perform floating-point operations in hardware was, for the longest time, something reserved for people with big wallets. This began to change around the time that Intel released the 8087 FPU coprocessor in 1980, featuring hardware support for floating-point arithmetic at a blistering 50 KFLOPS. Notably, the 8087 uses a stack-based architecture, a major departure from existing FPUs. Recently [Ken Shirriff] took a literal closer look at this stack circuitry to see what it looks like and how it works.

Nearly half of the 8087’s die is taken up by the microcode frontend and bus controller, with a block containing constants like π alongside the FP calculation-processing datapath section taking up much of the rest. Nestled along the side are the eight registers and the stack controller. At 80 bits per FP number, the required registers and related were pretty sizeable for the era, especially when you consider that the roughly 60,000 transistors in the 8087 were paired alongside the 29,000 transistors in the 16-bit 8086.

Each of the 8087’s registers is selected by the decoded instructions via a lot of wiring that can still be fairly easily traced despite the FPU’s die being larger than the CPU it accompanied. As for the unique stack-based register approach, this turned out to be mostly a hindrance, and the reason why the x87 FP instructions in the x86 ISA are still quite maligned today. Yet with careful use, providing a big boost over traditional code, this made it a success by that benchmark, even if MMX, SSE, and others reverted to a stackless design.

915 MHz Forecast: Rolling Your Own Offline Weather Station

December 19, 2025 by Matt Varian 4 Comments

There are a lot of options for local weather stations; most of them, however, are sensors tied to a base station, often requiring an internet connection to access all features. [Vinnie] over at vinthewrench has published his exploration into an off-grid weather station revolving around a Raspberry Pi and an RTL-SDR for communications.

The weather station has several aspects to it. The main sensor package [Vinnie] settled on was the Ecowitt WS90, capable of measuring wind speed, wind direction, temperature, humidity, light, UVI, and rain amount. The WS90 communicates at 915 MHz, which can be read using the rtl_433 project. The WS90 is also available for purchase as a standalone sensor, allowing [Vinnie] to implement his own base station.

For the base station, [Vinnie] uses a weatherproof enclosure that houses a 12V battery with charger to act as a local UPS. This powers the brains of the operation: a Raspberry Pi. Hooked to the Pi is an RTL-SDR with a 915 MHz antenna. The Pi receives an update from the WS90 roughly every 5 seconds, which it can decode using the rtl_433 library. The Pi then turns that packet into structured JSON.

The JSON is fed into a weather model backend that handles keeping track of trends in the sensor data, as well as the health of the sensor station. The backend has an API that allows for a dashboard weather site for [Vinnie], no internet required.

Thanks, [Vinnie], for sending in your off-grid weather station project. Check out his site to read more about his process, and head over to the GitHub page to check out the technical details of his implementation. This is a great addition to some of the other DIY weather stations we’ve featured here.

Cheap 3D Printer Becomes CNC Wood Engraver

December 19, 2025 by Lewin Day 8 Comments

3D printers are built for additive manufacturing. However, at heart, they are really just simple CNC motion platforms, and can be readily repurposed to other tasks. As [Arseniy] demonstrates, it’s not that hard to take a cheap 3D printer and turn it into a viable wood engraver.

The first attempt involved a simple experiment—heating the 3D printer nozzle, and moving it into contact with a piece of wood to see if it could successfully leave a mark. This worked well, producing results very similar to a cheap laser engraving machine. From there, [Arseniy] set about fixing the wood with some simple 3D-printed clamps so it wouldn’t move during more complex burning/engraving tasks. He also figured out a neat trick to simply calibrate the right Z height for wood burning by using the built in calibration routines. Further experiments involved developing a tool for creating quality G-Code for these engraving tasks, and even using the same techniques on leather with great success.

If you need to mark some patterns on wood and you already have a 3D printer, this could be a great way to go. [Arseniy] used it to great effect in the production of a plywood dance pad. We’ve featured some other great engraver builds over the years, too, including this innovative laser-based project. Video after the break.

Continue reading “Cheap 3D Printer Becomes CNC Wood Engraver” →