Aside from GPUs, you don’t hear much about co-processors these days. [bitluni] perhaps missed those days, because he found a way to squeeze a 160 core RISC V supercluster onto a single m.2 board, and shared it all on GitHub.

OK, sure, each core isn’t impressive– he’s using CH32V003, so each core is only running at 48 MHz, but with 160 of them, surely it can do something? This is a supercomputer by mid-80s standards, after all.  Well, like anyone else with massive parallelism, [bitluni] decided to try a raymarcher. It’s not going to replace RTX anytime soon, but it makes for a good demo.

Like his previous m.2 project, an LED matrix,  the cluster is communicating over PCIe via a WCH CH382 serial interface. Unlike that project, blinkenlights weren’t possible: the tiny, hair-thin traces couldn’t carry enough power to run the cores and indicator LEDs at once. With the power issue sorted, the serial interface is the big bottleneck. It turns out this cluster can crunch numbers much faster than it can communicate. That might be a software issue, however, as the cluster isn’t using all of the CH382’s bandwidth at the moment. While that gets sorted there are low-bandwidth, compute-heavy tasks he can set for the cluster. [bitluni] won’t have trouble thinking of them; he has a certain amount of experience with RISCV microcontroller clusters.

We were tipped off to this video by [Steven Walters], who is truly a prince among men. If you are equally valorous, please consider dropping informational alms into our ever-present tip line. 

Running DOOM on ARM? Old hat. Running Doom (2016) on an ARM SBC? Well, that’s a bit more interesting, and [Interfacing Linux] shows us how with this handy guide, and in a video embedded below.

The ARM SBC in question is the Radxa Orion O6, which claims to be the world’s first open source ARMv9 motherboard. It has a 12-core ARM9.2 SoC from Cix, and crucially for gaming, a PCIe x16 slot to fit a graphics card. There’s onboard graphics in the SoC, of course, but that’s only going to cut it for old DOOM, not Doom (2016).

Obviously there is no ARMv9 build of this nine-year-old classic. Thus, a certain degree of hacking is required. An x86 emulation layer called FEX is used to run Steam, which includes the Proton compatibility layer to sit between the Linux system and the Windows system calls the games are making.

So, again: Windows games, running via a compatibility layer on a Linux system running on an x86 emulator, running on another Linux system, running on ARM hardware. Yeah, we’d call that a hack, and just possibly cursed. The amazing thing is that it works. As long as you use a PCI 3.0 graphics card, anyway; apparently newer ones don’t work, or at least not the one [Interfacing Linux] had to try. (Some report better luck with newer NVIDIA cards.) Which is a pity, because every game tested is GPU-throttled on this system. Considering the CPU should be handling all the emulation, that just goes to show how GPU-heavy even 10-year-old games are.

[Interfacing Linux] seems to enjoy running things where they should not; we just wrote up their SteamOS console.

This isn’t the first time a Radxa board has shown up on Hackaday either, but they don’t seem to be nearly as popular as the fruit-flavoured competition for the sort of projects we usually see. If you’ve got a good project using one of these powerful ARM boards– or anything else, don’t hesitate to send us a tip!

Like the rest of us, 8-bit hardware is not getting any newer, and failed ROMs are just a fact of life. Of course you can’t call up Commadore corporation for replacement parts anymore, so something is needed. [Peirs Rocks] wasn’t satisfied with the existing options, so he came up with the Software Defined Retro ROM to serve as a drop-in replacement for 2364, 2332, and 2316 ROM chips.

Physically, the Software Defined Retro ROM is a PCB that matches the footprint of the original ROM chip, and holds an STM32F4 family microcontroller with a number of extra pins facing upwards. Some of those pins are for programming, so you can flash the board in-situ without removing it from the system using a Pi Pico. The others pins are jumpers for image selection or chip configuration. Depending which STM32 you use, you can have upto 16 ROM images on the board, at whatever chip select behaviour you require. The ROM’s chip select lines could be configured at the factory to answer to HIGH or LOW, and this board can handle either with a jumper swap.

The documentation on the GitHub is very well done, for which we applaud [Piers]. Instructions and demos are also available in the video embedded below. We could certainly see this hack becoming popular in the retrocomputer community, especially as everything ages and memories continue to, uh, y’know. What were we talking about, again?

Oh, right, ROMs. You might think an mask ROM would last a very long time, but it’s been a very long time since some of these were made. Best to dump them while you still can. If the chip is really far gone electrically, you might try decoding a photograph of the die.

It’s always clock time at Hackaday, and this time we have an interesting hack of a clock by [danjovic]– the CIS4, a Cistercian digital clock.

The Cistertians, in case you weren’t paying close attention to European holy orders during the 13th to 15th centuries were the group of monks you’d most likely have found us in. They were the hackers of the middle ages, establishing monestaries across western Europe that were chock full of hacks– including their own numeral system. Cistercian numerals were much more efficient (in spaces and penstrokes) than the Roman numerals they replaced, and even the “Arabic” numerals that replaced them. A single glyph could record anything from 1 to 9,999. (The Europeans hadn’t yet cottoned on to zero.)

Depending how you wanted to count time, a single glyph could be used; it looks like [danjovic] is using the thousands and hundreds portions of the glyph for hours and the tens and ones for minutes. This is all accomplished with a 4×4 neopixel matrix, run by an Attiny85 Digispark with a DS3231 RTC module keeping time. A slight simplification is required to reduce the glyphs to 4×4, but we don’t think the monks would mind. For those of us who don’t wear tonsures, an easy read mode scrolls the time in Arabic numerals. (Which still aren’t super easy,with only 4×4 LEDs to display them. See the demo video embedded below and try and guess the time.)

One nice quality of life feature is an LDR for ambient light detection, to automatically adjust the neopixels’ brightness. The hackiest part, which we thought was really clever, is the enclosure: it’s a cheap LED ceiling light. This provides a diffuser, housing and mounting hardware with decent design for no effort. A 3D-printed mask sits between the diffuser and the LEDs and doubles as a PCB holder. All very elegant.

[danjovic] did include a buzzer in the design, but does say if its been programed to sound off for matins, nones and vespers. In any case, at least it’s easier to read than his binary-coded-octal clock that we featured a few years back. This isn’t our first look at this number system,so evidently people can read them with practice.

Have you made or seen a cool clock? Send us a tip. We always have time for clocks.

EFI from cables is something every ham loves to hate. What if you modulated, that, though, using an ordinary cable as an antenna? If you used something ubiquitous like a video cable, you might have a very interesting exploit– which is exactly what [Xieyang Sun] and their colleagues have done with TEMPEST-LoRa, a technique to encode LoRa packets into video files.

The concept is pretty simple: a specially-constructed video file contains information to be broadcast via LoRa– the graphics card and the video cable serve as the Tx, and the Rx is any LoRa module. Either VGA or HDMI cables can be used, though the images to create the LoRa signal are obviously going to differ in each case. The only restriction is that the display resolution must be 1080×1920@60Hz, and the video has to play fullscreen. Fullscreen video might make this technique easy to spot if used in an exploit, but on the other hand, the display does not have to be turned on at the time of transmission. If employed by blackhats, one imagines syncing this to power management so the video plays whenever the screen blanks. 

According to the pre-print, a maximum transmission distance of 81.7m was achieved, and at 21.6 kbps. That’s not blazing fast, sure, but transmission out of a totally air-gapped machine even at dialup speeds is impressive. Code is on the GitHub under an MIT license, though [Xieyang Sun] and the team are white hats, so they point out that it’s provided for academic use. There is a demo video, but as it is on bilbili we don’t have an easy way to embed it. The work has been accepted to the ACM Conference on Computer and Communications Security (2025), so if you’re at the event in Taiwan be sure to check it out. 

We’ve seen similar hacks before, like this one that uses an ethernet cable as an antenna. Getting away from RF, others have used fan noise, or even the once-ubiquitous HDD light. (And here we thought casemakers were just cheaping out when they left those off– no, it’s security!)

Thanks to [Xieyang Sun] for the tip! We’ll be checking the tips line for word from you, just as soon as we finish wrapping ferrites around all our cables.

Like many of us of a certain vintage, [Dillan Stock] at The Stock Pot is nostalgic for VHS tapes. It’s not so much the fuzzy picture or the tracking issues we miss, but the physical experience the physical medium brought to movie night. To recreate that magic, [Dillan] made a Modern VHS with NFC and ESPHome.

NFC tags are contained in handsomely designed 3D printed cartridges. You can tell [Dillan] put quite a bit of thought into the industrial design of these: there’s something delightfully Atari-like about them, but they have the correct aspect ratio to hold a miniaturized movie poster as a label. They’re designed to print in two pieces (no plastic wasted on supports) and snap together without glue. The printed reader is equally well thought out, with print-in-place springs for that all important analog clunk.

Electronically, the reader is almost as simple as the cartridge: it holds the NFC reader board and an ESP32. This is very similar to NFC-based audio players we’ve featured before, but it differs in the programming. Here, the ESP32 does nothing related directly to playing media: it is simply programmed to forward the NFC tag id to ESPHome. Based on that tag ID, ESPHome can turn on the TV, cue the appropriate media from a Plex server (or elsewhere), or do… well, literally anything. It’s ESPHome; if you wanted to make this and have a cartridge to start your coffee maker, you could.

If this tickles your nostalgia bone, [Dillan] has links to all the code, 3D files and even the label templates on his site. If you’re not sold yet, check out the video below and you might just change your mind. We’ve seen hacks from The Stock Pot before, everything from a rebuilt lamp to an elegant downspout and a universal remote.

How many times do you have to forget your keys before you start hacking on the problem? For [Binh], the answer was 5 in the last month, and his hack was to make a gesture-based door unlocker. Which leads to the amusing image of [Binh] in a hallway throwing gang signs until he is let in.

The system itself is fairly simple in its execution: the existing deadbolt is actuated by a NEMA 17 stepper turning a 3D printed bevel gear. It runs 50 steps to lock or unlock, apparently, then the motor turns off, so it’s power-efficient and won’t burn down [Binh]’s room.

The software is equally simple; mediapipe is an ML library that can already do finger detection and be accessed via Python. Apparently gesture recognition is fairly unreliable, so [Binh] just has it counting the number of fingers flashed right now. In this case, it’s running on a Rasberry Pi 5 with a webcam for image input. The Pi connects via USB serial to an ESP32 that is connected to the stepper driver. [Binh] had another project ready to be taken apart that had the ESP32/stepper combo ready to go so this was the quickest option. As was mounting everything with double-sided tape, but that also plays into a design constraint: it’s not [Binh]’s door.

[Binh] is staying in a Hacker Hotel, and as you might imagine, there’s been more penetration testing on this than you might get elsewhere. It turns out it’s relatively straightforward to brute force (as you might expect, given it is only counting fingers), so [Binh] is planning on implementing some kind of 2FA. Perhaps a secret knock? Of course he could use his phone, but what’s the fun in that?

Whatever the second factor is, hopefully it’s something that cannot be forgotten in the room. If this project tickles your fancy, it’s open source on GitHub, and you can check it out in action and the build process in the video embedded below.

After offering thanks to [Binh] for the tip, the remaining words of this article will be spent requesting that you, the brilliant and learned hackaday audience, provide us with additional tips.

When it comes to text, how small is too small? The experts say a six point font is the minimum for readability, but as [James Bowman] shows us, you can get away with half of that. 

The goal is to produce a 40-character display on a 24 mm x 24 mm LCD that has a resolution of 240 x 240 to show a serial terminal (or other data) on the “TermDriver2” USB-to-Serial adapter. With 24 lines, that’s a line per millimeter: very small text. Three points, to be precise, half what the experts say you need. Diving this up into 40 columns gives a character cell of six by nine pixels. Is it enough?

Not by itself, no. That’s where the hack comes in: sub-pixel rendering. After all, a “white” pixel on an LCD is actually three elements: a red, a green, and a blue subpixel, stacked side-by-each. Drive each of those subpixels independently and 240 pixels now becomes 720. That’s plenty for a 40 column terminal.

The article discusses how, in general terms, they pulled off the subpixel rendering and kept the font as legible as possible. We think it’s a good try, though the colored fringe around the characters can be uncomfortable to look at for some people — and then we can’t forget the physical size of the characters being 1 mm tall.

If this trick were being used on a larger display with a 240-wide resolution, we’d say “yes, very legible, good job!”– but at this size? We hope we can find our reading glasses. Still, it’s a neat trick to have in your back pocket for driving low-resolution LCDs.

It may not surprise you that aside from improving legibility, subpixel rendering is also used for pixel (er, sub-pixel) art.

It’s been awhile since we checked in with Canada’s Edison Motors, so let’s visit [DeBoss Garage] for an update video. To recap, Edison Motors is a Canadian company building diesel-electric hybrid semi-trucks and more.

Well, they’ve thankfully moved out of the tent in their parents’ back yard where the prototype was built. They’ve bought themselves a company town: Donald, British Columbia, complete with a totally-not-controversial slogan “Make Donald Great Again”.

More interesting is that their commercial-off-the-shelf (COTS), right-to-repair centered approach isn’t just for semi-trucks: they’re now a certified OEM manufacturer of a rolling heavy truck chassis you can put your truck cab or RV body on, and they have partnered with three coach-builders for RVs and a goodly number of manufacturing partners for truck conversion kits. The kits were always in the plan, but selling the rolling chassis is new.

One amazingly honest take-away from the video is the lack of numbers for the pickups: top speed, shaft horsepower, torque? They know what all that should be, but unlike the typical vaporware startup, Edison won’t tell you the engineering numbers on the pickup truck kits until it has hit the race track and proved itself in the real world. These guys are gear-heads first and engineers second, so for once in a long time the adage “engineers hate mechanics” might not apply to a new vehicle.

The dirt track is the first thing under construction in Donald, so hopefully the next update we hear from Edison Motors will include those hard numbers, including pesky little things like MSRP and delivery dates. Stay tuned.

In our last post about an electric truck, a lot of you in the comments wanted something bigger, heavier duty, not pure battery, and made outside the USA. Well, here it is.

Thanks to [Keith Olson] for the tip. Remember, the lines are always open!

When you hear “PS2” and “Windows 95,” you probably think someone forgot a slash and are talking about peripherals, but no — this hack is very much about the Sony PlayStation 2, the best-selling game console of all time. [MeraByte] walks us through the possibly ridiculous task of installing Windows 95 on the last hardware anyone at Microsoft would ever endorse in a video you can watch below.

Obviously, the MIPS-based Emotion Engine at the heart of the PS2 is not going to be able to handle x86 instructions Win95 is expecting, but that’s all solved by the magic of emulation. [MeraByte] is running a version of Bochs, an x86 emulator that has been built for PS/2 after trying and failing to install Windows (both 3.1 and 95) to an experimental DOSBox build.

As expected, it is not a smooth journey for [MeraByte], but the flailing about and troubleshooting make for entertaining viewing. Once loaded, it works surprisingly well, in that anything works at all. Unfortunately, neither the mouse nor Ultimate Doom 95 worked. We suppose that ultimately means that this hack fails since even Doom can run Doom. The mouse thing is also important, probably.

If you have a PlayStation 2, maybe skip Windows 95 and try running GoLang.  If you do have DOOM running on the PlayStation 2, send us a tip. There was never an official release for PS2, but after 26 years, someone must have done it by now.

You know what the worst thing about the Steam Deck is? Being able to play your games on the go. Wouldn’t it be better if it was a screenless brick that lived under your TV? Well, maybe not, but at least one person thought so, because [Interfacing Linux] has created the GeekDeck, a Steam OS console of sorts in this video embedded below.

The hack is as simple as can be: he took a GEEKOM A5, a minicomputer with very similar specs to the Steam Deck, and managed to load SteamOS onto it. We were expecting that to be a trial that took most of the video’s runtime, but no! Everything just… sorta worked. It booted to a live environment and installed like any other Linux. Which was unexpected, but Steam has released SteamOS for PC. 

In case you weren’t aware, SteamOS is an immutable distribution based on Arch Linux. Arch of course has all the drivers to run on… well, any modern PC, but it’s the immutable part that we were expecting to cause problems. Immutable distributions are locked down in a similar manner to Mac OS (everything but /home/ is typically read-only, even to the superuser) and SteamOS doesn’t ship with package manager that can get around this, like rpm-ostree in Fedora’s Silverblue ecosystem. Actually, if you don’t have a hardware package that matches the SteamDeck to the same degree this GEEKOM does, Bazzite might be a good bet– it’s based on Siverblue and was made to be SteamOS for PC, before Steam let you download their OS to try on your PC.

Anyway, you can do it. Should you? Well, based on the performance shown in the video, not if you want to run triple-A games locally. This little box is no more powerful than the SteamDeck, after all. It’s not a full gaming rig. Still, it was neat to see SteamOS off of the ‘deck and in the wild.

Usually we see hacks that use the guts of the SteamDeck guts with other operating systems, not the other way around. Like the Bento Box AR machine we liked so much it was actually  featured twice.  The SteamDeck makes for a respectable SBC, if you can find a broken one. If not, apparently a Chinese MiniPC will work just as well.

Procedural generation is a big part of game design these days. Usually you generate your map, and [Fractal Philosophy] has decided to go one step further: using a procedurally-generated world from an older video, he is procedurally generating history by simulating the rise and fall of empires on that map in a video embedded below.

Now, lacking a proper theory of Psychohistory, [Fractal Philosophy] has chosen to go with what he admits is the simplest model he could find, one centered on the concept of “solidarity” and based on the work of [Peter Turchin], a Russian-American thinker. “Solidarity” in the population holds the Empire together; external pressures increase it, and internal pressures decrease it. This leads to an obvious cellular automation type system (like Conway’s Game of Life), where cells are evaluated based on their nearest neighbors: the number of nearest neighbors in the empire goes into a function that gives the probability of increasing or decreasing the solidarity score each “turn”. (Probability, in order to preserve some randomness.) The “strength” of the Empire is given by the sum of the solidarity scores in every cell.

Each turn, Empires clash, with the the local solidarity, sum strength, and distance from Imperial center going into determining who gains or loses territory. It is a simple model; you can judge from the video how well it captures the ebb and flow of history, but we think it did surprisingly well all things considered. The extra 40-minute video of the model running is oddly hypnotic, too.

After a dive into more academic support for the main idea, and a segue into game theory and economics, a slight complication is introduced later in the video, dividing each cell into two populations: “cooperators” or “selfish” individuals.

This allows for modeling of internal conflicts between the two groups. This hitch gives a very similar looking map at the end of its run, although has an odd quirk that it automatically starts with a space-filling empire across the whole map that quickly disintegrates.

Unfortunately, the model not open-source, but the ideas are discussed in enough detail that one could probably produce a very similar algorithm in an afternoon. For those really interested, [Fractal Philosophy] does offer a one-time purchase through his Patreon. It also includes the map-generating model from his last video.

We’re much more likely to talk about simulating circuits, or feature projects that use fluid simulations here at Hackaday, but this hack of a history model

Kumiko is a form of Japanese woodworking that uses small cuts of wood (probably offcuts) to produce artful designs. It’s the kind of thing that takes zen-like patience to assemble, and years to master– and who has time for that? [Paper View] likes the style of kumiko, but when all you have is a 3D printer, everything is extruded plastic.

His video, embedded below, focuses mostly on the large tiled piece and the clever design required to avoid more than the unavoidable unsightly seams without excessive post processing. (Who has time for that?) The key is a series of top pieces to hide the edges where the seams come together. The link above, however, gives something more interesting, even if it is on Makerworld.

[Paper View] has created a kumiko-style (out of respect for the craftspeople who make the real thing, we won’t call this “kumiko”) panel generator, that allows one to create custom-sized frames to print either in one piece, or to assemble as in the video. We haven’t looked at MakerWorld’s Parametric Model Maker before, but this tool seems to make full use of its capabilities (to the point of occasionally timing out). It looks like this is a wrapper for OpenScad (just like Thingiverse used to do with Customizer) so there might be a chance if enough of us comment on the video [Paper View] can be convinced to release the scad files on a more open platform.

We’ve featured kumiko before, like this wood-epoxy guitar,  but for ultimate irony points, you need to see this metal kumiko pattern made out of nails. (True kumiko cannot use nails, you see.)

Thanks to [Hari Wiguna] for the tip, and please keep them coming!

Multimaterial printing was not invented by BambuLabs, but love them or hate them the AMS has become the gold standard for a modern multi-material unit. [Daniel]’s latest Mod Bot video on the Box Turtle MMU (embedded below) highlights an open source project that aims to bring the power and ease of AMS to Voron printers, and everyone else using Klipper willing to put in the work.

The system itself is a mostly 3D printed unit that sits atop [Daniel]’s Voron printer looking just like an AMS atop a BambuLab. It has space for four spools, with motorized rollers and feeders in the front that have handy-dandy indicator LEDs to tell you which filament is loaded or printing. Each spool gets its own extruder, whose tension can be adjusted manually via thumbscrew. A buffer unit sits between the spool box and your toolhead.

Aside from the box, you need to spec a toolhead that meets requirements. It needs a PTFE connector with a (reverse) boden tube to guide the filament, and it also needs to have a toolhead filament runout sensor. The sensor is to provide feedback to Klipper that the filament is loaded or unloaded. Finally you will probably want to add a filament cutter, because that happens at the toolhead with this unit.  Sure, you could try the whole tip-forming thing, but anyone who had a Prusa MMU back in the day can tell you that is easier said than done. The cutter apparently makes this system much more reliable.

In operation, it looks just like a BambuLabs printer with an AMS installed. The big difference, again, is that this project by [Armored Turtle] is fully open source, with everything on GitHub under a GPL-3.0 license. Several vendors are already producing kits; [Daniel] is using the LDO version in his video.

It looks like the project is well documented–and [Mod Bot] agrees, and he reports that the build process is not terribly difficult (well, if you’re the kind of person who builds a Voron, anyway), and adding the AFC Klipper Addon (also by [Armored Turtle]) was easy as pie. After that, well. It needs calibration. Calibration and lots of tuning, which is an ongoing process for [Daniel]. If you want to see that, watch the video below, but we’ll spoil it for you and let you know it really pays off. (Except for lane 4, where he probably needs to clean up the print.)We’ve featured open-source MMUs before, like the Enraged Rabbit Carrot Feeder, but it’s great to see more in this scene, especially something that looks like it can take on the AMS. It’s not the only way to get multimaterial– there’s always tool-changers, or you could just put in a second motion system and gantry.

Coming in hot from Cornell University, students [Amanda Huang], [Caroline Hohner], and [Rhea Goswami] bring a project that is guaranteed to tickle the funny bone of anyone in the under-40 set, and sadists of all ages: The Tamagochi Torture Chamber.

In case you somehow missed it, Bandai’s Tamagochi is a genre-defining digital pet that was the fad toy at the turn of the millennium, and has had periodic revivals since. Like the original digital pet, there are three pushbuttons to allow you to feed, play with, and clean your digital pet. These affect the basic stats of happiness, health, food and weight in ways that will be familiar to anyone who played with the original Tamagochi. Just as with the original, mistreatment or neglect causes the Tamagochi to “die” and display a tombstone on the TFT display.

Where the “Torture Chamber” part comes in is the presence of an accelerometer and soft physics simulation– the soft physics gets an entire core of the Pi Pico at the heart of this build dedicated to it, while the other core handles all inputs, display and game logic. What this enables is the ability to bounce the digital pet off the walls of its digital home with an adorable squish (and drop in health stat) by tilting the unit. You can check that out in the demo video blow.

Is it overkill for a kids toy to have a full soft body simulation, rather than just a squish-bounce animation? Probably, but for an ECE project, it lets the students show off their chops… and possibly work out some frustrations.

We won’t judge. We will point you to other Tamagotchi-inspired projects, though: like this adorable fitness buddy, or this depressingly realistic human version.

If you’ve got an innovative way to torture video game characters, or a project less likely to get you on Skynet’s hitlist, don’t forget to send in a tip!

We like scale models here, but how small can you shrink the very large? If you’re [Frans], it’s pretty small indeed: his Micro Tellurium fits the orbit of the Earth on top of an ordinary pencil. While you’ll often see models of Earth, Moon and Sun’s orbital relationship called “Orrery”, that’s word should technically be reserved for models of the solar system, inclusive of at least the classical planets, like [Frans]’s Gentleman’s Orrery that recently graced these pages. When it’s just the Earth, Moon and Sun, it’s a Tellurium.

The whole thing is made out of brass, save for the ball-bearings for the Earth and Moon. Construction was done by a combination of manual milling and CNC machining, as you can see in the video below. It is a very elegant device, and almost functional: the Earth-Moon system rotates, simulating the orbit of the moon when you turn the ring to make the Earth orbit the sun. This is accomplished by carefully-constructed rods and a rubber O-ring.

Unfortunately, it seems [Franz] had to switch to a thicker axle than originally planned, so the tiny moon does not orbit Earth at the correct speed compared to the solar orbit: it’s about half what it ought to be. That’s unfortunate, but perhaps that’s the cost one pays when chasing smallness. It might be possible to fix in a future iteration, but right now [Franz] is happy with how the project turned out, and we can’t blame him; it’s a beautiful piece of machining.

It should be noted that there is likely no tellurium in this tellurium — the metal and the model share the same root, but are otherwise unrelated. We have featured hacks with that element, though.

Thanks to [Franz] for submitting this hack. Don’t forget: the tips line is always open, and we’re more than happy to hear you toot your own horn, or sing the praises of someone else’s work.

Have you ever finished up a bit of code and thought that typing “git push” in a terminal is just not a satisfying finish? So did [penumbriel], so he built a big red button he could smash instead.

This is a very simple hack: an Arduino sits inside a 3D-printed case that holds a big, red button. The case itself is very sturdily made to withstand a good satisfying smack: it has thick walls, brass insets, and rubber feet to protect the de The code for the Arduino is very, very simple: it spoofs a USB HID using the standard keyboard library, and automatically types out “git push” whenever the button is pressed. Or smashed, because you know you’re going to want to slam that thing. So far, so good– very innovative for 2006, right?

The detail that made this project stand out in 2025 was the technique [penumbriel] used for lettering– we’re always looking

for new ways to make a good front panel. In this case, the letters were printed as a valley, and filled with silicone adhesive. To protect the top surface of the print, soapy water was used as a mask. The silicone would not adhear to the wet plastic, so all [penumbriel] had to do was peel it off after it had cured, leaving solid white inside. It’s a neat trick, and a great way to use up an old tube of silicone before it goes hard. You could also use it for injection molding, but this is a great use for the dregs.

This might go well next to the programmer’s macro pad we featured a while back, but it really needs to stay as a big red button for maximum satisfaction.

If he’s anything like us [Duncan Hall] was probably equal parts excited and disgusted when he found a 1987 Macintosh SE case at a garage sale. Excited, because not every day do vintage computers show up at these things. Disgusted, because it had been gutted and coated in house paint; the previous owner apparently wanted to make an aquarium. [Duncan] wanted to make a computer, and after 15 years, he finally did, calling it the PhoeNIX SE.

The NIX part of the name might make you suspect he’s running Linux on it, which yes, he absolutely is. The guts of this restomod were donated from a Dell XPS laptop, whose Core i7 CPU and motherboard power the project. A 9.7″ LCD serves in place of the original monochrome CRT, held in place by 3D printed hardware. While a purist might complain, it’s not like anyone makes replacement CRTs anymore, and once that’s gone? You might as well go full modern. (The analog board, on the other hand, is available. So is the logic board, if you were wondering. Lacking a CRT, some might have chosen e-ink instead, but the LCD looks good here.)

Having gone full modern, well, there’s no need for the M5011’s dual floppies, so one of them holds a webcam and monitor for a modern experience. A zoom call from that case would be a bit surreal, but we really appreciate the use of the empty floppy bay to keep the clean lines of the Macintosh SE unaltered. The other floppy bay (this is a dual-floppy unit) appears empty; we might have put an SD-card reader or something in there, but we absolutely agree with [Duncan]’s choice to 3D Print a new back panel and keep all I/O on the rear of the case, as God and Steve Jobs intended.

However you feel about restomodding retrocomputers (and we’re aware it’s a controversial practice), I think we can all agree this is a much better fate for the old Mac than becoming an aquarium. Thanks to [Loddington] for the tip.

If you’re on the side of the aisle that prefers to see restorations than restomods, the tips line is waiting for some quality restorations.

We’ve seen a lot of projects based on the Pi Pico, but a nuclear reactor simulation is a new one. This project was created by [Andrew Shim], [Tyler Wisniewski] and another group member for Cornell’s ECE 4760 class on embedded design (which should silence naysayers who think the Pi Pico can’t be a “serious” microcontroller), and simulates the infamous soviet RMBK reactor of Chernobyl fame. 

The simulation uses a 4-bit color VGA model. The fission model includes uranium fuel, water, graphite moderator, control rods and neutrons. To simplify the math, all decayed materials are treated identically as non-fissile, so no xenon poisoning is going to show up, for example. You can, however, take manual control to both scram the reactor and set it up to melt down with the hardware controller.

The RP2040’s dual-core nature comes in handy here: one core runs the main simulation loop, and the main graphic on the top of the VGA output; the other core generates the plots on the bottom half of the screen, and the Geiger-counter sound effect, and polls the buttons and encoders for user input. This is an interesting spread compared to the more usual GPU/CPU split we see on projects that use the RP2040 with VGA output.

An interesting wrinkle that has been declared a feature, not a bug, by the students behind this project, is that the framebuffer cannot keep up with all the neutrons in a meltdown simulation. Apparently the flickering and stuttering of frame-rate issues is “befitting of the meltdown scenario”. The idea that ones microcontroller melts down along with the simulated reactor is rather fitting, we agree. Check it out in a full walkthrough in the video below, or enjoy the student’s full writeup at the link above.

This project comes to us via Cornell University’s ECE 4760 course, which we’ve mentioned before. Thanks to [Hunter Adams] for the tipoff. You may see more student projects in the coming weeks.