We’ve seen just about every possible way to make a clock here at Hackaday over the years. So it’s rare to have a first, but here we are with [Twisted & Tinned], who’s made a novel clock with a diffraction grating.

The display of the clock looks for all the world like a jumble of LEDs, that is, until you place the grating in front of it. Those LEDs are addressable multi-color parts, and each digit is generated at a different color all on top of each other. The grating splits out these colors, resulting in a magical set of floating LED figures.

Behind those LEDs is a Pi Pico, but that’s just one of many microcontrollers that could have powered this project. It’s the use of the diffraction grating in a novel way with those LEDs that makes the difference, and we rather like it. He’s also managed to get the grating pattern in the 3D printed surround for a shimmering look, by printing directly onto a diffraction grating sheet. That in particular is a technique we’ve looked at before in detail.

youtube.com/embed/1DD9vaVy1H8?…

hackaday.com/2026/06/03/a-diff…

Replacing a 3D printer’s extruder with a cutting blade seems like an easy way to do things like vinyl cutting, but you cannot just put on any blade and expect good results. The right type of blade is called a drag knife and it’s designed so that it follows the direction in which you’re cutting. You can get these in dedicated vinyl cutting machines, as well as in the form of attachments for the likes of CNC machines. How to use them with an old Anycubic Mega S FDM printer is demonstrated by [Cocoanix 3D Printing] in a recent video.

For a bit more background information you can peruse for example this write-up by [Kronos Robotics], who goes through the steps of selecting the right blade, cutting mat and such for use with a CNC machine.

For the 3D printer in the video a Roland vinyl cutter style holder and blades were bought off AliExpress, for which then a custom 3D printed mount was designed, though you can often get a ready-made one off your usual 3D model sources. Following this you get into the hardest part, being the software and making sure you don’t cut too deep into the vinyl through its backing paper.

Fortunately most of the hard work here is done already by the Polycut project, which is precisely designed to help you turn a 3D printer or similar into a vinyl cutter or plotter. This takes in an SVG file and generates the appropriate g-code, after which you better have gotten your Z-offset calibration right if you want that perfect result. With all that in place it’s then actually quite easy to cut your very own vinyl without shelling out big bucks for a dedicated machine.

Of course, it’ll likely never be as fast as those machines, requires more calibration and have a more limited cutting space, but as it’s not a permanent modification and probably less crazy than putting a laser engraver module on a commercial FDM printer like the Bambu Lab H2D.

youtube.com/embed/KcpcjyyMpYQ?…

hackaday.com/2026/06/02/turnin…

[Chris Doble] has high ambitions: he’s making his own scanning-electron microscope, and as the first step he’s built a high-vacuum system. This required its own controller to manage the various electronics involved in the system, which he’s documented and open-sourced.

The vacuum system itself starts with a rotary-vane roughing pump, which can bring a chamber down from atmospheric pressure to about 10^-3 millibar. This is still too high a pressure, so the second stage is a turbomolecular high-vacuum pump, which can operate from 18 millibar down to 10^-7 millibar. To protect the turbomolecular pump in case the roughing pump suddenly stops, it includes an anti-suckback valve. Connected to these pumps is a pressure gauge which uses a pair of sensors to sense the entire pressure range. All this setup worked well, but the turbomolecular pump and the pressure sensor each used their own interfaces, while [Chris] wanted a single interface for the eventual microscope.

[Chris] therefore designed his own controller based on the Raspberry Pi Pico 2, with firmware written in Rust. The pressure gauge uses an RS-232 interface, which he connected to the Pico’s UART pins using an RS-232 level shifter, with a null modem to swap over the transmitting and receiving pins. The turbomolecular pump used an RS-485 interface, which required a converter circuit and some level-shifting resistors. A custom PCB and 3D-printed case hold the final circuit, which provides a host computer with a single USB interface. When [Chris] tested the controller, the vacuum chamber reached a pressure of 10^-6 millibar, and was still slowly falling when he ended the test.

This isn’t the first vacuum chamber controller we’ve seen. Of course, this assumes that the pressure gauge already has a controller; if not, we’ve also covered one of those. To see the inspiration for [Chris]’s project, check out [Ben Krasnow]’s scanning-electron microscope.

youtube.com/embed/Ku04_mVZx_E?…

hackaday.com/2026/06/02/a-high…

There are a lot of single board computers on the market these days, so you can be forgiven if you missed the LuckFox Lyra. Its main claim to fame seems to be that it shares the Pi Pico’s 51 mm x 21 mm footprint while being powerful enough to run a full Linux system– or at least, it was. Now its claim to fame is as a device you can interact with no peripherals, accessing the terminal via Morse code. That’s thanks to [Gabriel Broussard Korr] and his Morstdin project, which should run on just about anything POSIX-compliant, by dint of a being a clever sh script at heart.

Of course, with most POSIX-compliant systems, you’ll need to alter the script to account for some kind of periferal to do the Morse I/O– not so on the LuckFox Lyra, which has a built-in LED and a single usable button. It actually has two buttons, but one of them is RESET and you can’t use that for anything but its intended purpose. The BOOT button, on the other hand, becomes user input after the system has started. One button, one LED? It’s almost like LuckFox designed this SBC for Morse! Admittedly we’d prefer an audible output, but adding a buzzer would detract from the purity of this implementation.

He’s had to extend the code, of course, since Samuel Morse did not expect all of the special characters you’re likely to encounter on the terminal. The resultant Programmer’s Morse, or PMorse is a straightforward extension, but [Gabriel] didn’t stop there: he’s also added a set of commands he describes as “vim-like” make using this headless device easier by doing things like deleting whole words or flash the line you’re working on so you can make sure you haven’t made any errors.

If that wasn’t enough, he’s also put an LLM on it. Because in the Year of Our Lord 2026, you apparently cannot escape the frakkin’ toasters by jumping your rag-tag fleet into the 128 MB of RAM on this tiny SBC. Still, his inclusion of Llamma.cpp does add one thing to the project: it can now claim to be the world’s smallest stand-alone chatbot. It’s also the only one that speaks Morse. That’s got to be worth some bragging rights.

[Gabriel] may have a thing for physically tiny Linux devices– his last project, which we featured, was about using Linux on old smartphones with Termux.

Thanks to [Gabriel] for the tip!

Header image credit Luckfox.

hackaday.com/2026/06/02/does-y…

Pallets are a wonderful way to package goods and move them around, but especially the wooden ones have a very finite lifespan. This means that many of them are discarded every day, even though there is still good wood on them. Even if it’s not the highest quality wood, you can still use it for some nice wooden items, like the tea tray that [GR Woodworking] recently put together.

The reclaimed wood is the typical fast-growing, soft type, with the suspicion of it being paulownia here. Of course, wooden pallets use a wide variety of wood varieties, so not all reclaimed wood is equally suitable for applications like this, and identifying the type can be a challenge in itself.

In the video it’s shown how the wood is planed to make it smooth and straight, before the joints are created and it is married to the poplar or aspen base plate. Of note is that absolutely no power tools or bulky things like router tables are used here, just basic hand tools that should make this kind of woodworking accessible to people even without that kitted-out woodworking shop.

After assembly it’s finished with Vararhana oil-based stain to give it a darker look and really bring out the grain. Naturally, since it’s a tea tray it has to be commissioned with a proper tea ceremony, which it passes with flying colors.

youtube.com/embed/tnNvp0LoJiw?…

hackaday.com/2026/06/02/from-s…

Four years ago the EMF hacker camp in the UK released a new kind of event badge. The Tildagon was designed to be a recurring event badge, useful for the next EMF rather than destined to be e-waste. With the 2026 event coming up there’s a new Tildagon called the Spaceagon, and as you might expect it’s very familiar indeed.

Tildagon owners can update their badge with the Spaceagon front panel, while those without one can buy the new badge. It has a few minor updates from its predecessor, including better buttons, LEDs, and display mounting, and there’s a compass, a joystick, and touch sensitive areas.

The Tildagon introduced its own add-on format, the Hexpansion. This year there’s the first official Hexpansion, a keyboard, using the same rubber moulding we see on quite a few maker projects. We like the Hexpansion idea because it uses an edge connector rather than a set of pins on the device, but at the cost of more expensive badge parts.

If you’re going to EMF you should be able to order yourself a Spaceagon, or an upgrade kit if you already own a Tildagon. Meanwhile we covered the 2024 version back when it arrived, and surprisingly this isn’t the first keyboard add-on for it either.

hackaday.com/2026/06/02/the-20…

While many operating systems seem to try to prevent you from peeking under the hood, Unix and Linux positively encourage it. One great tool that we’ve looked at before is strace. Using this tool, you can see details about every system call a program makes. As you might imagine, for any significant program, the output from strace can be huge.

While I’m not always a fan of GUIs, this is one of those cases where making the data easier to browse is a great idea. Enter strace-tui, a text-based GUI for strace from [Rodrigodd]. The program can parse output from strace or manage the strace execution itself, and either way, display the data in a useful way.

I started out looking at [janestreet’s] strace_ui, but the OCaml setup was throwing errors for me, so I just gave up. The strace-tui installs like many Rust programs, using cargo, and it went smoothly.

An Example

The strace-tui interface.
The only issue I had running the tool was that I don’t normally keep ~/.cargo/bin on my path. You can add it to your path, link the executable into your path, or solve that in any number of other ways.

As an example, I traced a symbolic link command (ln -sf nature.txt test.link). It is easy to pick out some essential information on the top line. The command took 112 system calls, 14 of them failed (which isn’t unexpected), there were no unfinished calls, no signals, and only a single PID.

The bottom shows things you can do. Arrows or j and k, along with the usual cursor control keys like Home and Page Down scroll through the list. The right and left arrows will expand or collapse items. That will show details about the call in question, including the arguments and return values. You can consult the help for all the details.

Useful Tools

The real power, though, lies in filtering out the noise and searching for specific things. If you are looking at something you don’t want to see, you can press a lowercase h to hide it, but note that it hides everything similar, not just an individual line. An uppercase H will bring up a filter dialog where you can include or exclude groups of data.

Searching is also a great way to find what you want. A slash key starts a search. The N key navigates with a lowercase entry moving forward and an uppercase one moving backward.

For example, if I only wanted to look at openat commands, I could open the dialog. Not only does it show filters, but it also shows how many things match (there are 30 instances of openat). Pressing a will toggle all entries off and then selecting openat greatly reduces the amount of output. I also selected symlinkat, read, and fstat so I would only look at the file-related items.
Peeking at the system call that does the actual linking.
Many of the file operations are related to loading shared libraries and locales. To find the actual line that makes the link, it was easy to press the slash key and some text from the file like test.link.

That will highlight the symlinkat line, which is no surprise, but this is a simple example. If you press Enter or the right arrow, you can see more detail, including arguments, the return value, the amount of time executing, and a backtrace that shows how your program made it to the call.

This is a simple example, but the program can also visualize multi-threaded or multi-process traces using graphs. That can be helpful for analyzing real programs.

Even this simple program has a lot of output. Sure, if you are trying to debug a locale-related problem, all of the lines about loading locale files that don’t exist might be gold. But most of the time, you don’t really care about all the standard loading scaffolding and a tool like this can help cut through the chatter.

Missing Links

According to the project page, there are some missing features, and we presume this is a roadmap for future development.

In particular, the program can’t filter traces for specific processes or threads. There’s also no way to copy details to the clipboard or export filtered traces out to a file. Of course, it is open source, so you can always volunteer to add some of this or your favorite feature.

If you give strace-tui a shot, or have other strace tips and tricks you’d like to share, let us know in the comments.

hackaday.com/2026/06/02/linux-…

We do sometimes go on about how absurdly powerful microcontrollers are these days, but this time it’s technically a microprocessor, not a microcontroller, at the heart of the build — specifically, an STM32MP2. Still, you know you’re living in the future when an STM32 of any sort can not only run [John Cronin]’s gk handheld game console, but provide 3D acceleration to boot.

Full disclosure: you’ve seen this handheld here before — sorta. That was version 3, which was an STM32-based handheld. V3 used the much less powerful STM32H7S7L8, with a single Cortex-M7 clocked at 600 MHz and a 2D NeoChrom GPU. The STM32MP2, by contrast, has dual Cortex-A35 cores running 1.5 GHz and a bonus Cortex-M33. It’s running a custom OS called gkos, which is mostly POSIX-compliant and boasts nigh-instantaneous boot times.

As with the last version, you can run a bevy of emulators from the 8-bit to the 32-bit era, but the added power and OpenGL support mean this handheld also runs N64 games via a fork of mupen64. There are also emulators for ‘real’ computers, namely Atari ST and XL, and a little-known thing known as a “PC”. DOSBox gets the equivalent performance of a 50 MHz 486, which means you can run all the classics, including DOOM, though that will be more performant running the native-running port of sdl-DOOM.

You also get extra inputs to play with and a bigger screen compared to the last version. Oh, and WiFi. There are accelerometers for tilt control, and did we mention the screen’s touch input is supported? If it weren’t for the form-factor, we’d call this a capable little computer. The GK handheld looks like an awesome handheld console, check it out in the demo video below.

youtube.com/embed/HnWTx0CX4E8?…

hackaday.com/2026/06/02/stm32-…