Even though digital cameras have lowered the barrier of entry to photography dramatically, as well as made it much easier for professionals and amateurs alike to capture stunning images without the burden of developing film, the technology behind them is considerably more complex than their analog counterparts. In fact, an analog film camera (not counting the lens) can be as simple as a lightproof box and a way to activate a shutter. Knowing that, any kind of film camera could be built for any number of applications, like this 3D-printed panoramic camera from [Denis Aminev].

The custom-built camera works by taking a standard roll of 35mm film, which is standardized to take 36 pictures, and exposing a wider section of the film to create a panorama. This reduces the number of pictures on the roll to 19. This is the fifth version of this camera, called the Infidex 176 V, and has everything a standard film camera would have, from an exposure counter, pressure plate for the film, a winder, interchangable lenses, a viewfinder, and a tripod mounting point. It does take a bit of work to assemble, as shown in the video linked below, but the final result is impressive and delivers a custom finished product not easily found or reproducible in off-the-shelf cameras.

The path to creating this camera was interesting as well, as [Denis]’s first custom film camera was a pinhole camera. From there he moved on to disassembling an SLR camera and attempting to reproduce all of its parts with 3D printed ones. With that in hand, he was able to modify this design into this panoramic camera which he likes because it reproduces the feel of widescreen movies. Although this camera reproduces all of the bells and whistles of a high quality analog camera, not all of these features are strictly necessary for taking pictures on film. Have a look at this minimum viable camera as well.

youtube.com/embed/zv_Ho8Yjjiw?…

hackaday.com/2026/02/20/panora…

Considering that the Nintendo DS already has its own remake of Super Mario 64, one might be tempted to think that porting the original Nintendo 64 version would be a snap. Why you’d want to do this is left as an exercise to the reader, but whether due to nostalgia or out of sheer spite, the question of how easy this would be remains. Correspondingly, [Tobi] figured that he’d give it a shake, with interesting results.

Of note that is someone else already ported SM64 to the DSi, which is a later version of the DS with more processing power, more RAM and other changes. The reason why the 16 MB of RAM of the DSi is required, is because it needs to load the entire game into RAM, rather than do on-demand reads from the cartridge. This is why the N64 made do with just 4 MB of RAM, which is as much RAM as the ND has. Ergo it can be made to work.

The key here is NitroFS, which allows you to implement a similar kind of segmented loading as the N64 uses. Using this the [Hydr8gon] DSi port could be taken as the basis and crammed into NitroFS, enabling the game to mostly run smoothly on the original DS.

There are still some ongoing issues before the project will be released, mostly related to sound support and general stability. If you have a flash cartridge for the DS this means that soon you too should be able to play the original SM64 on real hardware as though it’s a quaint portable N64.

youtube.com/embed/k1qQSgDAo0I?…

hackaday.com/2026/02/20/portin…

For today’s podcast Elliot Williams is joined by Jenny List, and we’re pushing the limits of mobile connectivity as Jenny’s coming to us from a North Sea ferry. We start by looking forward to the upcoming Hackaday Europe, with a new location in Lecco, Italy. We hope you can join us there!

There’s a bumper collection of hacks to talk about, with a novel soft pneumatic display, a CRT-based VR headset, an LCD photographic aperture, and a novel time-of-flight sensor array in the line-up.Then there are 3D printed PCBs, Scotch tape for a lens, and a project to map farts. We kid you not. Finally we wrap up with mind controlled toys, and a a treatise on requirements and specifications in an age of AI.

html5-player.libsyn.com/embed/…

Or download it yourself in glorious 192 kbps MP3.

Where to Follow Hackaday Podcast

Places to follow Hackaday podcasts:

• iTunes
• Spotify
• Stitcher
• RSS
• YouTube
• Check out our Libsyn landing page

News:

• 2026 Hackaday Europe Call For Participation: We Want You!

What’s that Sound?

• Congratulations to [Moogle], a hoopy frood who knows where his towel is.

Interesting Hacks of the Week:

• Real-Time 3D Room Mapping With ESP32, VL53L5CX Sensor And IMU
  
  • Random sample consensus

  
  

• A Computer That Fits Inside A Camera Lens
• Microfluidic Display Teaches The Basics
  
  • 3D Printing Pneumatic Channels With Dual Materials For Soft Robots

  
  

• 3D Printed Jack Mixes Two Filaments For Great Performance
• Custom VR Headset Uses Unconventional Displays
• Bruteforcing Accidental Antenna Designs

Quick Hacks:

• Elliot’s Picks:
  
  • Taking Photos With Scotch Tape Instead Of A Lens
  • New Tool Makes 3D Printed PCBs, Fast
  • Using 3D Printed Breadboards To Accommodate Wide Boards

  
  

• Jenny’s Picks:
  
  • Nobody Can Complain When You Fart, If It’s For Science!
  • Can A Scan Tool Kill A Car?
  • Retro Rover: LT6502 Laptop Packs 8-Bit Power On The Go

  
  

Can’t-Miss Articles:

• The Complicated Legacy Of Mind Controlled Toys
• The Requirements Of AI

hackaday.com/2026/02/20/hackad…

Magnet placement tools are great because they remove finger fumbling while ensuring correct polarity every time. [EmGi] has made a further improvement by making a version that auto-feeds from an internal stack of magnets.
A stack of magnets auto-feeds with every press of the plunger.
That is a trickier task than one might imagine, because magnets can have a pesky habit of being attracted in inconvenient ways, or flipping around and sticking where they should not. [EmGi] solves this with a clever rack and pinion mechanism to turn a single plunger press into a motion that shears one magnet from a stack and keeps it constrained while the same magnet responsible for holding it to the tip takes care of dragging it down a feed path. It’s easier to see it work in action, so check out the video (embedded below) in which [EmGi] explains exactly what is going on.

This design is actually an evolution of an earlier, non-reloading version. This new one is mechanically more complex, but if it looks useful you can get the design files from Printables or Makerworld and make your own.

The only catch is that this reloading design is limited in what sizes of magnet it can handle, because magnet behavior during feeding is highly dependent on the physical layout and movements. For a different non-reloading placement tool that works with any magnet size and is about as simple as one can get, you can make your own with little more than a bolt and a spring.

youtube.com/embed/k0yt9EvjzNI?…

Thanks [Keith] for the tip!

hackaday.com/2026/02/20/auto-r…

There was a period from the 1970s to the mid-2000s or so when a fixture underneath the family TV set was a VHS videocassette recorder. These were a masterpiece of cramming a color video signal into the restricted bandwidth of an affordable 1970s helical-scan tape deck, which was achieved by clever use of frequency shifting and FM carrier modulation. Very few of us will have had the ultimate iteration of the VHS format though, W-VHS, which managed the same trick but with HD video. But how? [Superchromat] is here with the answer.

W-VHS used a frequency modulated carrier, but instead of splitting luminance and chrominance in the frequency domain like its VHS ancestor, it did so in the time domain in the same way as some 1980s satellite TV standards did. Each line first contained the color information, then the brightness. Thus it sacrificed some color resolution and a little horizontal image resolution, but kept a much higher vertical image resolution. In the video below the break we go into significant detail about the compromises required to pull this off, and if you watch it through you’ll learn something about magnetic tape recording as well as FM.

The W-VHS standard is largely forgotten now as a last hurrah for the format, but it’s still in the sights of the VHS Decode project. The work in this video is helping them retrieve the highest quality images from these tapes, by capturing the raw RF from the heads and using DSP techniques to decode them.

youtube.com/embed/0GjWRQMFVA8?…

hackaday.com/2026/02/20/hd-on-…

During the Cold War, the specter of a nuclear “dead man’s switch” was central to the concept of Mutually Assured Destruction (MAD). In the event that one side was annihilated by the other, an automated system would be triggered to deliver a revenge strike that would ultimately destroy the attacker. It was the ultimate defense, as your enemy will never attack if they know doing so will inevitably lead to their own destruction.

The same idea has occasionally been employed by whistleblowers and journalists as well. Should the individual fail to check in regularly, a series of predetermined events will be set into motion. Again, the idea is defensive in nature. If somebody is in possession of information so damning that they could be abducted or even killed to keep it quiet, making arrangements to have that information be released to the public in the event anything should happen to them is a great way to stay safe.
A nuclear dead man’s switch is a key plot point in Dr. Strangelove.
But what about for the average person? In the past, there was no need for most people to think about something as elaborate as a dead man’s switch. But we live in interesting times, to say the least. In an information society such as ours, whistleblowers have never been more common, and the Internet has significantly blurred the definition of what it means to be a journalist.

For those living under a repressive regime or in a war zone, simply posting to social media can provide the outside world with an unfiltered look at what’s actually happening on the ground. A teenager with a cell phone has the potential to reach a wider audience than the legacy media — a powerful, but dangerous, proposition.

Even if you’re not in the middle of political upheaval, there are still reasons you might want to have previously secret information made available in the event of your death or incapacitation. Perhaps you’d like to send your loved ones a final personal message, or make sure the passwords for all your accounts get in the hands of whoever will be handling your estate.

Of course, one could argue that could be accomplished with little more than a notebook hidden in your sock drawer. But this is Hackaday, and over-engineering is the name of the game. So do you have a dead man’s switch? How is it implemented? Or is the whole idea just a bit too out there for you?

The Software Approach

We started discussing this topic internally here at Hackaday a few days ago after I came across LastSignal, an open source dead man’s switch application written by Claudio Benvenuti. It’s by no means the first piece of software of its type, as the idea has been floating around for years and there are both open and proprietary implementations available. But LastSignal has the sort of slick modern design that gets people interested, and the fact that you can self-host it is quite appealing.

LastSignal is designed to let you write encrypted messages that will remain a secret until the system has been triggered, at which point they will be sent off to the recipients you’ve configured. The default behavior is to try and contact you every month via your primary email address, and once the software picks up that you’ve missed enough of your normal check-ins, it will try to get in touch with your emergency contact. If it still doesn’t get a response, then the automated messages start getting sent out.

Again, this is not a new idea. Searching around, you can find other open source tools to achieve the same goal, such as dead-man-hand. If you’re not concerned with the behind-the-scenes implementation, you can even pay a service to handle it all for you. But there is something to be said for using a package that’s already been thoroughly tested and vetted by the community. Otherwise, you could just throw something together yourself with a Python script — although we’d hate to spend eternity roaming the astral plain in torment because our final messages didn’t get delivered due to a library update breaking our script.

Most of the projects we found along these lines are focused on sending messages that would be a secret until the time of their release. That makes sense, but we wondered if there were other tasks you might like your personal dead man’s switch to fire off in the event you’ve signed out permanently. For example, Al Williams suggested that some users might want to have their drives securely wiped in the event of their death. Any speculation as to why this was the first thing Al thought of will be left as an exercise for the reader.

Why Not a Physical Switch?

While a software solution is the easiest way to implement a dead man’s switch, it does have its downsides. As already mentioned, if you’re self-hosting the solution and aren’t careful, some seemingly inconsequential change or update could potentially knock out the software before it even has a chance to run. When we think of all the weirdo software issues we’ve had over the years, it makes us more than a little skeptical about trusting such an important task to the whims of our operating system.
A split-flap display seems perfect for a DIY dead man’s switch.
So what about a hardware solution? With so many WiFi capable microcontrollers on the market now, it would be trivial to put together a little dead man box that has just a display and a button on it — the display counts down the remaining time before the switch is triggered, and the button is used to reset the timer. If you don’t press the button in time, the MCU connects to the Internet and performs whatever task you’ve programmed. We bet you could put it together right now using stuff in your parts bin.

Now, we won’t pretend going from a pure software solution to a piece of custom hardware will completely remove the chances of something going wrong. After all, there’s still code being run, and that code could have bugs. But it does take away the innumerable variables that are introduced when said code is being run on a modern operating system. If your DIY dead man’s switch works today, you can be sure it will work the same way in a year from now as the whole system is in a fixed state.

Tin Foil Hat Not Included

Or maybe this is all crazy talk. Perhaps the complexity of either solution makes no sense for the average person, and just writing your important information down and telling your next of kin how to get access it after your passing is enough. Obviously there are downsides to this approach as well, notably the potential for your written information to get stale and no longer be valid when the time comes, but it’s a method that has worked for the vast majority of people for generations.

Is this a problem that needs a modern solution? Is a dead man’s switch best left to secret agents? The fact is, we’re all going to go sooner or later, so it’s something we need to give some thought to while we still have the chance. We’d love to hear what you think in the comments below.

hackaday.com/2026/02/20/ask-ha…

A few months back, Sandia National Laboratories announced they had acquired a new supercomputer. It wasn’t the biggest, but it still offered in their eyes something unique. This particular supercomputer contains NextSilicon’s much-hyped Maverick-2 ‘dataflow accelerator’ chips. Targeting the high-performance computing (HPC) market, these chips are claimed to hold a 10x advantage over the best GPU designs.
NextSilicon Maverick-2 OAM-2 module. (Credit: NextSilicon)
The strategy here appears to be somewhat of a mixture between VLIW, FPGAs and Sony’s Cell architecture, with a dedicated compiler that determines the best mapping of a particular calculation across the compute elements inside the chip. Naturally, the exact details about the internals are a closely held secret by NextSilicon and its partners (like Sandia), so we basically have only the public claims and PR material to go by.

Last year The Register covered this architecture along with a more in-depth look. What we can surmise from this is that it should perform pretty well for just about all applications, except for single-threaded performance. Of course, as a dedicated processor it cannot do CPU things, which is where NextSilicon’s less spectacular RISC-V-based CPU comes into the picture.

What’s apparent from glancing at the product renders on the NextSilicon site is that these Maverick-2 chips have absolutely massive dies, so they’re absolutely not cheap to manufacture. Whether they’ll make more of a splash than Intel’s Itanium or NVIDIA’s brute force remains to be seen.

hackaday.com/2026/02/20/nextsi…

A modern computer can be a great productivity tool. It can also be a great source of distractions. To solve that issue, [Quackieduckie] built the e-typer—a device for writing without distraction.

[Quackieduckie] refers to the device as a “low-cost e-ink typewriter” which lays out the basic mode of operation. It consists of a 4.2 inch e-ink screen, combined with an Orange Pi Zero 2W running the Armbian operating system. It’s set up to boot straight into a document editor so there’s no messing around with other software that could get in the way of productivity. The components are all wrapped up in a tidy 3D printed housing, which includes a foldable stand so you can prop the screen up wherever you happen to be working. [Quackieduckie] built the device to work with any USB-C keyboard, probably figuring that those eager to maximize productivity will already have the typing device of their dreams on hand. Code for the project is available on GitHub for those eager to replicate the build.

We’ve featured similar builds in the past, often referred to as “writing decks.” They’re becoming increasingly popular as people look for distraction-free, ad-free tech experiences. A great example is this clamshell design with an integrated keyboard. If you’re building your own productivity aids in your home lab, don’t hesitate to notify the tipsline!

hackaday.com/2026/02/20/cheap-…

As anyone who’s made a thing knows, a lot of work goes into bringing something from idea to completion. But there’s also considerable satisfaction in the process. [Willian] recently did exactly that, and shares the joyful experience of creating a homebrew handheld game gadget from scratch. It runs a homebrewed Tetris clone (as well as Snake), and we love the results.

The game gadget uses an ATmega328P programmed via the Arduino IDE, and a 1.8″ TFT color LCD screen. It’s self-contained in a box with a few buttons as controls and runs off three AAA cells. [Willian] made the smart design choice to run the microcontroller at 8 MHz instead of the more common 16 MHz, because doing so meant the board can run at 3.3 V instead of 5 V. Why does this matter? The LCD display runs off 3.3 V as well, and if all components can run off the same supply and logic levels, it simplifies things considerably.

Also, creating a 3.3 V supply is a simple matter of three alkaline cells in series with an LDO (low drop-out) regulator, which is great for a handheld device. We do note that AA cells have a considerably higher energy density and capacity than AAA cells and are usually the better choice, but one works with what one has, and sometimes the space and weight saved by AAA is just too good to pass up.

The software has some notable approaches to keep things responsive and optimal. Instead of defining each of the Tetris pieces as a 2D shape, [Willian] instead pre-defines each piece (and their rotations) so that rotating a piece is just an index change in an array, instead of a transform implementing a rotation. Also, full-screen redraws are comparatively slow over SPI and caused flickering, so only cells that have changed are redrawn to the screen to keep things responsive. The code is all on GitHub, and it’s a great peek at how things get implemented under the hood.

The enclosure is just cardboard, and it does the job in [Willian]’s case. But we’ll point out that cardboard is actually a highly adaptable material from which to prototype. With just a few tips and a little care, paper products can be your new best friend when it comes to one-offs and prototypes.

hackaday.com/2026/02/19/the-jo…

It’s becoming somewhat of a theme that machine-generated content – whether it’s code, text or graphics – keeps pushing people to their limits, mostly by how such ‘AI slop’ is generally of outrageously poor quality, but as in the case of [Vincent Driessen] there’s also a clear copyright infringement angle involved. Recently he found that Microsoft had bastardized a Git explainer graphic which he had in 2010 painstakingly made by hand, with someone at Microsoft slapping it on a Microsoft Learn explainer article pertaining to GitHub.

As noted in a PC Gamer article on this clear faux pas, Microsoft has since quietly removed the graphic and replaced it with something possibly less AI slop, but with zero comment, and so far no response to a request for comment by PC Gamer. Of course, The Internet Archive always remembers.

What’s probably most vexing is that the ripped-off diagram isn’t even particularly good, as it has all the hallmarks of AI slop graphics: from the nonsensical arrows that got added or modified, to heavily mutilated text including changing ‘Time’ to ‘Tim’ and ‘continuously merged’ into ‘continvuocly morged’. This makes it obvious that whoever put the graphic on the Microsoft Learn page either didn’t bother to check, or that no human was involved in generating said page.

Spot the differences. (Credit: Vincent Driessen (left), Microsoft (right) )
It definitely gives a dystopian ‘Dead Internet’ vibe where the fruits of past labor are being cynically regurgitated and spat out in the form of AI slop that bears little resemblance to the original, and should send real humans either running off in abject terror or fall over in uncontrollable laughter.

Even if this output was the result of [Vincent]’s original graphic getting scraped and shoved struggling and screaming into a diffusion model’s training dataset, there are so many dead giveaways that it was based on this original: from the text blurbs, to the use of the label ‘feature branches’ that’s retained in the reproduction even though the second feature branch has been trimmed.

All of this raises many uncomfortable questions about copyright in the context of both large language models and diffusion models, with cases like these making it clear that sometimes substantial elements of copyrighted works are being reproduced nearly verbatim. Depending on the associated copyright license, this can result in very expensive copyright infringement lawsuits, with some of these already working, or having worked their way through various courts pertaining to primarily stock images and books.

And to think that all that Microsoft would have had to do here was to check with [Vincent] for the license on the graphic if they had wanted to use it. As [Vincent] indicates, he would have been more than happy to do so if a backlink and credit was provided. This obviously is the human way to do things, where a human contacts a fellow human being to inquire about their thoughts on a topic, or peruses the works by fellow humans to find something to their liking prior to contacting said human with a usage question.

In this era of ‘just ask the machine’ by mashing in a query on a prompt, it would seem that this particular case will be far from the last one. The cynical take here is that the value of human output has been reduced to mere training data for the content machines, but maybe Microsoft will surprise us here with a tearful apology and real actions to prevent such events from ever happening again.

hackaday.com/2026/02/19/micros…

The RF section of the ESP32-C6 die. (Credit: electronupdate, YouTube)
With the ESP32-P4 not having any wireless functionality and instead focusing on being a small SoC, it makes sense to combine it with a second chip that handles features like WiFi and Bluetooth. This makes the Guition ESP32-P4-M3 module both a pretty good example of how the P4 will be used, and an excellent opportunity to tear into, decap and shoot photos of the dies of both the P4 and the ESP32-C6 in this particular module, courtesy of [electronupdate]. There also the blog post for those who just want to ogle the shinies.

After popping the metal shield on the module, you can see the contents as in the above photo. The P4 inside is a variant with 32 MB of PSRAM integrated along with the SoC die. This results in a die shot both of this PSRAM and the P4 die, though enough of the top metal seems to remain to clearly see the latter.

The Boya brand Flash chip is quite standard inside, and along with a glance at the inside of one of the crystal oscillators we get to glance at the inside of the C6 MCU. This is a much more simple chip than the P4, with the RF section quite obvious. The total die sizes are 2.7 x 2.7 mm for the C6 and 4.29 x 3.66 mm for the P4.

youtube.com/embed/-Nu0tjDCbbM?…

hackaday.com/2026/02/19/poking…

When you’re livestreaming, it can be tempting to fire off all kinds of wacky sound effects like you’re a morning radio DJ back in the heady days of 1995. If that’s who you want to be, you might like this soundboard project from [Biker Glen].

The build is based around an RP2040 microcontroller. It’s paired with an I2S digital-to-analog converter for sound output, which in turn feeds a small amplifier hooked up to a speaker or a line output. The RP2040 is programmed to respond to MIDI commands by playing various sounds in response, which are loaded off a microSD card. It’s able to act as a USB MIDI host, which allows it to work seamlessly with all sorts of off-the-shelf MIDI controllers like the MIDI Fighter or the Novation Launchpad.

It’s an interesting hardware solution to a problem that you could probably also solve with software on your streaming machine, especially if you’ve already got a USB MIDI controller. However, there’s something to be said for lightening the load when your streaming computer is already doing lots of hard work to truck video up to the cloud already. Files are on Github if you’re eager to replicate the build.

Soundboards are just fun, which is why we’ve featured them before. Meanwhile, if you’re whipping up your own streaming accessories at home, be sure to let us know on the tipsline!

hackaday.com/2026/02/19/rp2040…

As common as the Xbox 360 was, the development kits (XDKs) for these consoles are significantly less so. This makes it even more tragic when someone performs a botched surgery on one of these rare machines, leaving it in dire straits. Fortunately [Josh Davidson] was able to repair the XDK in question for a customer, although it entailed replacing the GPU, CPU and fixing many traces.

The Xbox 360 Development Kit is effectively a special version of the consumer console — with extra RAM and features that make debugging software on the unit much easier, such as through direct access to RAM contents. They come in a variety of hardware specifications that developed along with the game console during its lifecycle, with this particular XDK getting an upgrade to being a Super Devkit with fewer hardware restrictions.

Replacing the dead GPU was a new old stock Kronos 1 chip. Fortunately the pads were fine underneath the old GPU, making it easy to replace. After that various ripped-off pads and traces were discovered underneath the PCB, all of which had to be painstakingly repaired. Following this the CPU had apparently suffered heat damage and was replaced with a better CPU, putting this XDK back into service.

youtube.com/embed/dMw72RDX-LY?…

hackaday.com/2026/02/19/fixing…

We are going to bet that as a kid, you had a View-Master. This toy has been around for decades and is, more or less, a handheld stereoscope. We never thought much about the device’s invention until we saw a recent video from [View Master Travels and Peter Dibble]. It turns out that the principle of the whole thing was created by the well-known [Charles Wheatstone]. However, it was piano repairman [William Gruber] who invented what we think of as the View-Master.

[Gruber] didn’t just work on normal pianos, but complex player pianos and, in particular, the pianos used to record player piano rolls. He was also, as you might expect, a stereo photography enthusiast. Many of the ideas used in automating pianos would show up in the View-Master and the machines that made the reels, too. In the 1930s, stereoscopes were not particularly popular and were cumbersome to use. Color film was also a new technology.

[Gruber] realized that a disk-like format would be easy to use and, more importantly, easy to mass produce. The reels had a few features to simplify their use. For example, if you show each image in sequence, you’d eventually see pictures upside down. [Gruber’s] solution? Use an odd number of pairs and advance the reel two positions for each jump forward. That way, you never show an image to the wrong eye.

The model “A” didn’t look much like the View-Master you probably remember. By 1940, the toy was a hit. But initially, it wasn’t really a toy so much as a way for adults to view distant sites. Of course, World War II could have stopped the enterprise dead, but instead, they shifted to producing training aids for the military. The War Department would buy 100,000 viewers and about 6 million reels to help train soldiers to identify aircraft and ships, as well as to estimate range.

Training was always a key use of the View-Master technology, but the company eventually bought a competitor with rights to Disney films and exploded into a must-have toy. When the company was bought by GAF, the focus on the toy market grew. Despite some efforts to keep the company relevant in an era with virtual reality and other 3D technologies, View-Master is, sadly, a bit of nostalgia now, even though you can still buy them. But it is impressive that despite many changes to the viewer and the production methods, the View-Master reel remained virtually unchanged despite the production of about 1.5 billion of them. Sure, there were fancy viewers that had audio tracks, too, but the basic idea of an odd number of film frames mounted in a circle in a notched disk remained the same.

These days, a phone can be your View-Master, at least, if you can cross your eyes. Want to preserve your View-Master reels for posterity? So did [W. Jason Altice].

youtube.com/embed/TwKjaH0lwrg?…

hackaday.com/2026/02/19/the-hi…

Thermoforming is the process of softening a material enough so that it can be tweaked into a new shape, with the source of the thermal energy being not particularly relevant. Correspondingly, after [Zion Brock]’s recent video on his journey into thermoforming PLA with a mold and a heat gun, he got many comments suggesting that he should use hot water instead.

We covered his previous video as well, in which he goes through the design steps of making these grilles for a retro-styled, 3D printed radio. The thermoforming method enables him to shape the curvy grille with a heat gun and two-piece mold in a matter of minutes, rather than spending hours more time printing and removing many supports.

Theoretically using hot water instead of hot air would provide a more equal application of heat, but putting your hands into 70°C water does require some more precautions. There’s also the issue that PLA is very hygroscopic, so the part requires drying afterwards to prevent accelerated hydrolysis. Due to the more even heating, the edge of the PLA that clamped into the mold also softened significantly, causing it to pop out of the mold and requiring a small design modification to prevent this.

Basically, aqua-thermoforming like this has many advantages, as its slower and more consistent, but it’s less straightforward to use than hot air. This makes both a useful tool when you’re looking at doing thermoforming.

youtube.com/embed/ClvOfAKTN_E?…

hackaday.com/2026/02/19/thermo…

The media is full of breathless reports that AI can now code and human programmers are going to be put out to pasture. We aren’t convinced. In fact, we think the “AI revolution” is just a natural evolution that we’ve seen before. Consider, for example, radios. Early on, if you wanted to have a radio, you had to build it. You may have even had to fabricate some or all of the parts. Even today, winding custom coils for a radio isn’t that unusual.

But radios became more common. You can buy the parts you need. You can even buy entire radios on an IC. You can go to the store and buy a radio that is probably better than anything you’d cobble together yourself. Even with store-bought equipment, tuning a ham radio used to be a technically challenging task. Now, you punch a few numbers in on a keypad.

The Human Element

What this misses, though, is that there’s still a human somewhere in the process. Just not as many. Someone has to design that IC. Someone has to conceive of it to start with. We doubt, say, the ENIAC or EDSAC was hand-wired by its designers. They figured out what they wanted, and an army of technicians probably did the work. Few, if any, of them could have envisoned the machine, but they can build it.

Does that make the designers less? No. If you write your code with a C compiler, should assembly programmers look down on you as inferior? Of course, they probably do, but should they?

If you have ever done any programming for most parts of the government and certain large companies, you probably know that system engineering is extremely important in those environments. An architect or system engineer collects requirements that have very formal meanings. Those requirements are decomposed through several levels. At the end, any competent programmer should be able to write code to meet the requirements. The requirements also provide a good way to test the end product.

Anatomy of a Requirement

System Design Process (public domain – from MIT Open Course).
A good requirement will look like this: “The system shall…” That means that it must comply with the rest of the sentence. For example, “The system shall process at least 50 records per minute.” This is testable.

Bad requirements might be something like “The system shall process many records per minute.” Or, “The system shall not present numeric errors.” A classic bad example is “The system shall use aesthetically pleasing cabinets.”

The first bad example is too hazy. One person might think “many” is at least 1,000. Someone else might be happy with 50. Requirements shouldn’t be negative since it is difficult to prove a negative. You could rewrite it as “The system shall present errors in a human-readable form that explains the error cause in English.” The last one, of course, is completely subjective.

You usually want to have each requirement handle one thing to simplify testing. So “The system shall present errors in human-readable form that explain the error cause in English and keep a log for at least three days of all errors.” This should be two requirements or, at least, have two parts to it that can be tested separately.

In general, requirements shouldn’t tell you how to do something. “The system shall use a bubble sort,” is probably a poor requirement. However, it should also be feasible. “The system shall detect lifeforms” doesn’t tell you how to make that work, but it is suspicious because it isn’t clear how that could work. “The system shall operate forever with no external power” is calling for a perpetual motion machine, so even if that’s what you wish for, it is still a bad requirement.
A portion of a typical NASA SRS requirements document
You sometimes see sentences with “should” instead of shall. These mark goals, and those are important, but not held to the same standard of rigor. For example, you might have “The system should work for as long as possible in the absence of external power.” That communicates the desire to work with no external power to the level that it is practical. If you actually want it to work at least for a certain period of time, then you are back to a solid and testable requirement, assuming such a time period is feasible.

You can find many NASA requirements documents, like this SRS (software requirements specification), for example. Note the table provides a unique ID for each requirement, a rationale, and notes about testing the requirement.

Requirement Decomposition

High-level requirements trace down to lower-level requirements and vice versa. For example, your top-level requirement might be: “The system shall allow underwater research at location X, which is 600 feet underwater.” This might decompose to: “The system shall support 8 researchers,” and “The system shall sustain the crew for up to three months without resupply.”

The next level might levy requirements based on what structure is needed to operate at 600 feet, how much oxygen, fresh water, food, power, and living space are required. Then an even lower level might break that down to even more detail.

Of course, a lower-level document for structures will be different from a lower-level requirement for, say, water management. In general, there will be more lower-level requirements than upper-level ones. But you get the idea. There may be many requirment documents at each level and, in general, the lower you go, the more specific the requirements.

And AI?

We suspect that if you could leap ahead a decade, a programmer’s life might be more like today’s system architect. Your value isn’t understanding printf or Python decorators. It is in visualizing useful solutions that can actually be done by a computer.

Then you generate requirements. Sure, AI might help improve your requirements, trace them, and catalog them. Eventually, AI can take the requirements and actually write code, or do mechanical design, or whatever. It could even help produce test plans.

The real question is, when can you stop and let the machine take over? If you can simply say “Design an underwater base,” then you would really have something. But the truth is, a human is probably more likely to understand exactly what all the unspoken assumptions are. Of course, an AI, or even a human expert, may ask clarifying questions: “How many people?” or “What’s the maximum depth?” But, in general, we think humans will retain an edge in both making assumptions and making creative design choices for the foreseeable future.

The End Result

There is more to teaching practical mathematics than drilling multiplication tables into students. You want them to learn how to attack complex problems and develop intuition from the underlying math. Perhaps programming isn’t about writing for loops any more than mathematics is about how to take a square root without a calculator. Sure, you should probably know how things work, but it is secondary to the real tools: creativity, reasoning, intuition, and the ability to pick from a bewildering number of alternatives to get a workable solution.

Our experience is that normal people are terrible about unambiguously expressing what they want a computer to do. In fact, many people don’t even understand what they want the computer to do beyond some fuzzy handwaving goal. It seems unlikely that the CEO of the future will simply tell an AI what it wants and a fully developed system will pop out.

Requirements are just one part of the systems engineering picture, but an important one. MITRE has a good introduction, especially the section on requirements engineering.

What do you think? Is AI coding a fad? The new normal? Or is it just a stepping stone to making human programmers obsolete? Let us know in the comments. Although they have improved, we still think the current crop of AI is around the level of a bad summer intern.

hackaday.com/2026/02/19/the-re…

Introduction

In October 2025, we discovered a series of forum posts advertising a previously unknown stealer, dubbed “Arkanix Stealer” by its authors. It operated under a MaaS (malware-as-a-service) model, providing users not only with the implant but also with access to a control panel featuring configurable payloads and statistics. The set of implants included a publicly available browser post-exploitation tool known as ChromElevator, which was delivered by a native C++ version of the stealer. This version featured a wide range of capabilities, from collecting system information to stealing cryptocurrency wallet data. Alongside that, we have also discovered Python implementation of the stealer capable of dynamically modifying its configuration. The Python version was often packed, thus giving the adversary multiple methods for distributing their malware. It is also worth noting that Arkanix was rather a one-shot malicious campaign: at the time of writing this article, the affiliate program appears to be already taken down.

Kaspersky products detect this threat as Trojan-PSW.Win64.Coins.*, HEUR:Trojan-PSW.Multi.Disco.gen, Trojan.Python.Agent.*.

Technical details

Background

In October 2025, a series of posts was discovered on various dark web forums, advertising a stealer referred to by its author as “Arkanix Stealer”. These posts detail the features of the stealer and include a link to a Discord server, which serves as the primary communication channel between the author and the users of the stealer.

Example of an Arkanix Stealer advertisement

Upon further research utilizing public resources, we identified a set of implants associated with this stealer.

Initial infection or spreading

The initial infection vector remains unknown. However, based on some of the file names (such as steam_account_checker_pro_v1.py, discord_nitro_checker.py, and TikTokAccountBotter.exe) of the loader scripts we obtained, it can be concluded with high confidence that the initial infection vector involved phishing.

Python loader

The Python loader is the script responsible for downloading and executing the Python-based version of the Arkanix infostealer. We have observed both plaintext Python scripts and those bundled using PyInstaller or Nuitka, all of which share a common execution vector and are slightly obfuscated. These scripts often serve as decoys, initially appearing to contain legitimate code. Some of them do have useful functionality, and others do nothing apart from loading the stealer. Additionally, we have encountered samples that employ no obfuscation at all, in which the infostealer is launched in a separate thread via Python’s built-in threading module.

Variants of Python loaders executing the next stage

Upon execution, the loader first installs the required packages — namely, requests, pycryptodome, and psutil — via the pip package manager, utilizing the subprocess module. On Microsoft Windows systems, the loader also installs pywin32. In some of the analyzed samples, this process is carried out twice. Since the loader does not perform any output validation of the module installation command, it proceeds to make a POST request to hxxps://arkanix[.]pw/api/session/create to register the current compromised machine on the panel with a predefined set of parameters even if the installation failed. After that, the stealer makes a GET request to hxxps://arkanix[.]pw/stealer.py and executes the downloaded payload.

Python stealer version

During our research, we obtained a sample of the Python implementation of the Arkanix stealer, which was downloaded from the endpoint hxxps://arkanix[.]pw/stealer.py by the previous stage.

The stealer’s capabilities — or features, as referred to by the author — in this version are configurable, with the default configuration predefined within the script file. To dynamically update the feature list, the stealer makes a GET request to hxxps://arkanix[.]pw/api/features/{payload_id}, indicating that these capabilities can be modified on the panel side. The feature list is identical to the one that was described in the GDATA report.

Configurable options

Prior to executing the information retrieval-related functions, the stealer makes a request to hxxps://arkanix[.]pw/upload_dropper.py, saves the response to %TEMP%\upd_{random 8-byte name}.py, and executes it. We do not have access to the contents of this script, which is referred to as the “dropper” by the attackers.

During its main information retrieval routine, at the end of each processing stage, the collected information is serialized into JSON format and saved to a predefined path, such as %LOCALAPPDATA\Arkanix_lol\%info_class%.json.

In the following, we will provide a more detailed description of the Python version’s data collection features.

System info collection

Arkanix Stealer is capable of collecting a set of info about the compromised system. This info includes:

• OS version
• CPU and GPU info
• RAM size
• Screen resolution
• Keyboard layout
• Time zone
• Installed software
• Antivirus software
• VPN

Information collection is performed using standard shell commands with the exception of the VPN check. The latter is implemented by querying the endpoint hxxps://ipapi[.]co/json/ and verifying whether the associated IP address belongs to a known set of VPNs, proxies, or Tor exit nodes.

Browser features

This stealer is capable of extracting various types of data from supported browsers (22 in total, ranging from the widely popular Google Chrome to the Tor Browser). The list of supported browsers is hardcoded, and unlike other parameters, it cannot be modified during execution. In addition to a separate Chrome grabber module (which we’ll discuss later), the stealer itself supports the extraction of diverse information, such as:

• Browser history (URLs, visit count and last visit)
• Autofill information (email, phone, addresses and payment cards details)
• Saved passwords
• Cookies
• In case of Chromium-based browsers, 0Auth2 data is also extracted

All information is decrypted using either the Windows DPAPI or AES, where applicable, and searched for relevant keywords. In the case of browser information collection, the stealer searches exclusively for keywords related to banking (e.g., “revolut”, “stripe”, “bank”) and cryptocurrencies (e.g., “binance”, “metamask”, “wallet”). In addition to this, the stealer is capable of extracting extension data from a hardcoded list of extensions associated with cryptocurrencies.

Part of the extension list which the stealer utilizes to extract data from

Telegram info collection

Telegram data collection begins with terminating the Telegram.exe process using the taskkill command. Subsequently, if the telegram_optimized feature is set to False, the malware zips the entire tdata directory (typically located at %APPDATA%\Roaming\Telegram Desktop\tdata) and transmits it to the attacker. Otherwise, it selectively copies and zips only the subdirectories containing valuable info, such as message log. The generated archive is sent to the endpoint /delivery with the filename tdata_session.zip.

Discord capabilities

The stealer includes two features connected with Discord: credentials stealing and self-spreading. The first one can be utilized to acquire credentials both from the standard client and custom clients. If the client is Chromium-based, the stealer employs the same data exfiltration mechanism as during browser credentials stealing.

The self-spreading feature is configurable (meaning it can be disabled in the config). The stealer acquires the list of user’s friends and channels via the Discord API and sends a message provided by the attacker. This stealer does not support attaching files to such messages.

VPN data collection

The VPN collector is searching for a set of known VPN software to extract account credentials from the credentials file with a known path that gets parsed with a regular expression. The extraction occurs from the following set of applications:

• Mullvad VPN
• NordVPN
• ExpressVPN
• ProtonVPN

File retrieval

File retrieval is performed regardless of the configuration. The script relies on a predefined set of paths associated with the current user (such as Desktop, Download, etc.) and file extensions mainly connected with documents and media. The script also has a predefined list of filenames to exfiltrate. The extracted files are packed into a ZIP archive which is later sent to the C2 asynchronously. An interesting aspect is that the filename list includes several French words, such as “motdepasse” (French for “password”), “banque” (French for “bank”), “secret” (French for “secret”), and “compte” (French for “account”).

Other payloads

We were able to identify additional modules that are downloaded from the C2 rather than embedded into the stealer script; however, we weren’t able to obtain them. These modules can be described by the following table, with the “Details” column referring to the information that could be extracted from the main stealer code.

The Wallet patcher and Extra collector scripts are received in an encrypted form from the C2 server. To decrypt them, the attackers utilize the AES-GCM algorithm in conjunction with PBKDF2 (HMAC and SHA256). After decryption, the additional payload has its template placeholders replaced and is stored under a partially randomized name within a temporary folder.

Decryption routine and template substitution

Once all operations are completed, the stealer removes itself from the drive, along with the artifacts folder (Arkanix_lol in this case).

Native version of stealer

During our analysis, we were able to obtain both the release and debug versions of the native implementation, as both were uploaded to publicly available resources. The following are the key differences between the two:

• The release version employs VMProtect, but does not utilize code virtualization.
• The debug version communicates with a Discord bot for command and control (C2), whereas the release version uses the previously mentioned C2 domain arkanix[.]pw.
• The debug version includes extensive logging, presumably for the authors’ debugging purposes.

Notably, the native implementation explicitly references the name of the stealer in the VersionInfo resources. This naming convention is consistent across both the debug version and certain samples containing the release version of the implant.

Version info

After launching, the stealer implements a series of analysis countermeasures to verify that the application is not being executed within a sandboxed environment or run under a debugger. Following these checks, the sample patches AmsiScanBuffer and EtwEventWrite to prevent the triggering of any unwanted events by the system.

Once the preliminary checks are completed, the sample proceeds to gather information about the system. The list of capabilities is hardcoded and cannot be modified from the server side, in contrast to the Python version. What is more, the feature list is quite similar to the Python version except a few ones.

RDP connections

The stealer is capable of collecting information about known RDP connections that the compromised user has. To achieve this, it searches for .rdp files in %USERPROFILE%\Documents and extracts the full server address, password, username and server port.

Gaming files

The stealer also targets gamers and is capable to steal credentials from the popular gaming platform clients, including:

• Steam
• Epic Games Launcher
• net
• Riot
• Origin
• Unreal Engine
• Ubisoft Connect
• GOG

Screenshots

The native version, unlike its Python counterpart, is capable of capturing screenshots for each monitor via capCreateCaptureWindowA WinAPI.
In conclusion, this sample communicates with the C2 server through the same endpoints as the Python version. However, in this instance, all data is encrypted using the same AES-GCM + PBKDF2 (HMAC and SHA256) scheme as partially employed in the Python variant. In some observed samples, the key used was arkanix_secret_key_v20_2024. Alongside that, the C++ sample explicitly sets the User-Agent to ArkanixStealer/1.0.

Post-exploitation browser data extractor

This is an implant embedded within the resources of the C++ implementation. The author incorporated it into the resource section without applying any obfuscation or encryption. Subsequently, the stealer extracts the payload to a temporary folder with a randomly generated name composed of hexadecimal digits (0-9 and A-F) and executes it using the CreateProcess WinAPI. The payload itself is the unaltered publicly available project known as “ChromElevator”. To summarize, this tool consists of two components: an injector and the main payload. The injector initializes a direct syscall engine, spawns a suspended target browser process, and injects the decrypted code into it via Nt syscalls. The injected payload then decrypts the browser master key and exfiltrates data such as cookies, login information, web data, and so on.

Infrastructure

During the Arkanix campaign, two domains used in the attacks were identified. Although these domains were routed through Cloudflare, a real IP address was successfully discovered for one of them, namely, arkanix[.]pw. For the second one we only obtained a Cloudflare IP address.

Both servers were also utilized to host the stealer panel, which allows attackers to monitor their victims. The contents of the panel are secured behind a sign-in page. Closer to the end of our research, the panel was seemingly taken down with no message or notice.

Stealer panel sign-in page

Stealer promotion

During the research of this campaign, we noticed that the forum posts advertising the stealer contained a link leading to a Discord server dubbed “Arkanix” by the authors. The server posed as a forum where authors posted various content and clients could ask various questions regarding this malicious software. While users mainly thank and ask about when the feature promised by the authors will be released and added into the stealer, the content made by the authors is broader. The adversary builds up the communication with potential buyers using the same marketing and communication methods real companies employ. To begin with, they warm up the audience by posting surveys about whether they should implement specific features, such as Discord injection and binding with a legitimate application (sic!).

Feature votes

Additionally, the author promised to release a crypter as a side project in four to six weeks, at the end of October. As of now, the stealer seems to have been taken down without any notice while the crypter was never released.

Arkanix Crypter

Furthermore, the Arkanix Stealer authors decided to implement a referral program to attract new customers. Referrers were promised an additional free hour to their premium license, while invited customers received seven days of free “premium” trial use. As stated in forum posts, the premium plan included the following features:

• C++ native stealer
• Exodus and Atomic cryptocurrency wallets injection
• Increased payload generation, up to 10 payloads
• Priority support

Referral program ad and corresponding panel interface

Speaking of technical details, based on the screenshot of the Visual Studio stealer project that was sent to the Discord server, we can conclude that the author is German-speaking.

This same screenshot also serves as a probable indicator of AI-assisted development as it shares the common patterns of such assistants, e.g. the presence of the utils.cpp file. What provides even more confidence is the overall code structure, the presence of comments and extensive debugging log output.

Example of LLM-specific patterns

Conclusions

Information stealers have always posed as a serious threat to users’ data. Arkanix is no exception as it targets a wide range of users, from those interested in cryptocurrencies and gaming to those using online banking. It collects a vast amount of information including highly sensitive personal data. While being quite functional, it contains probable traces of LLM-assisted development which suggests that such assistance might have drastically reduced development time and costs. Hence it follows that this campaign tends to be more of a one-shot campaign for quick financial gains rather than a long-running infection. The panel and the Discord chat were taken down around December 2025, leaving no message or traces of further development or a resurgence.

In addition, the developers behind the Arkanix Stealer decided to address the public, implementing a forum where they posted development insights, conducted surveys and even ran a referral program where you could get bonuses for “bringing a friend”. This behavior makes Arkanix more of a public software product than a shady stealer.

Indicators of Compromise

Additional IoCs are available to customers of our Threat Intelligence Reporting service. For more details, contact us at crimewareintel@kaspersky.com.

File hashes
752e3eb5a9c295ee285205fb39b67fc4
c1e4be64f80bc019651f84ef852dfa6c
a8eeda4ae7db3357ed2ee0d94b963eff
c0c04df98b7d1ca9e8c08dd1ffbdd16b
88487ab7a666081721e1dd1999fb9fb2
d42ba771541893eb047a0e835bd4f84e
5f71b83ca752cb128b67dbb1832205a4
208fa7e01f72a50334f3d7607f6b82bf
e27edcdeb44522a9036f5e4cd23f1f0c
ea50282fa1269836a7e87eddb10f95f7
643696a052ea1963e24cfb0531169477
f5765930205719c2ac9d2e26c3b03d8d
576de7a075637122f47d02d4288e3dd6
7888eb4f51413d9382e2b992b667d9f5
3283f8c54a3ddf0bc0d4111cc1f950c0

Domains and IPs
arkanix[.]pw
arkanix[.]ru

securelist.com/arkanix-stealer…

Getting PCBs made is often the key step in taking a dodgy lab experiment and turning it into a functional piece of equipment. However, it can be tedious to wait for PCBs to ship, and that can really slow down the iterative development process. If you’ve got a 3D printer, though, there’s a neat way to make your own custom PCBs. Enter PCB Forge from [castpixel].
The online tool.
The concept involves producing a base and a companion mold on your 3D printer. You then stick copper tape all over the base part, using the type that comes with conductive adhesive. This allows the construction of a fully conductive copper surface across the whole base. The companion mold is then pressed on top, pushing copper tape into all the recessed traces on the base part. You can then remove the companion mold, quickly sand off any exposed copper, and you’re left with a base with conductive traces that are ready for you to start soldering on parts. No etching, no chemicals, no routing—just 3D printed parts and a bit of copper tape. It rarely gets easier than this.

You can design your PCB traces in any vector editor, and then export a SVG. Upload that into the tool, and it will generate the 3D printable PCB for you, automatically including the right clearances and alignment features to make it a simple press-together job to pump out a basic PCB. It bears noting that you’re probably not going to produce a four-layer FPGA board doing advanced high-speed signal processing using this technique. However, for quickly prototyping something or lacing together a few modules and other components, this could really come in handy.

The work was inspired by a recent technique demonstrated by [QZW Labs], which we featured earlier this year. If you’ve got your own hacks to speed up PCB production time, or simply work around it, we’d love to know on the tipsline!

hackaday.com/2026/02/19/new-to…