Aussie Researchers Say They Can Bring The Iron Age To Mars

September 13, 2025 by Tyler August 1 Comment

It’s not martian regolith, bu it’s the closest chemical match available to the dirt in Gale Crater. (Image: Swinburne University)

Every school child can tell you these days that Mars is red because it’s rusty. The silicate rock of the martian crust and regolith is very rich in iron oxide. Now Australian researchers at CSIRO and Swinburn University claim they know how to break that iron loose.

In-situ Resource Utilization (IRSU) is a big deal in space exploration, with good reason. Every kilogram of resources you get on site is one you don’t have to fight the tyranny of the rocket equation for. Iron might not be something you’d ever be able to haul from Earth to the next planet over, but when you can make it on site? You can build like a Victoria is still queen and it’s time to flex on the French.

The key to the process seems to be simple pyrolysis: they describe putting dirt that is geochemically analogous to martian regolith into a furnace, and heating to 1000 °C under Martian atmospheric conditions to get iron metal. At 1400 °C, they were getting iron-silicon alloys– likely the stuff steelmakers call ferrosilicon, which isn’t something you’d build a crystal palace with.

It’s not clear how economical piling red dust into a thousand-degree furnace would be on Mars– that’s certainly not going to cut it on Earth– but compared to launch costs from Earth, it’s not unimaginable that martian dirt could be considered ore.

The schematic on the left and the assembled circuit on the right.

How To Make A Simple MOSFET Tester

September 13, 2025 by John Elliot V 3 Comments

Over on YouTube our hacker [VIP Love Secretary] shows us how to make a simple MOSFET tester.

This is a really neat, useful, elegant, and simple hack, but the video is kind of terrible. We found that the voice-over constantly saying “right?” and “look!” seriously drove us to distraction. But this is a circuit which you should know about so maybe do what we did and watch the video with subtitles on and audio off.

To use this circuit you install the MOSFET you want to test and then press with your finger the spare leg of each of two diodes; in the final build there are some metal touch pads attached to the diodes to facilitate this. One diode will turn the MOSFET off, the other diode will turn the MOSFET on, and the LED will show you which is which.

Continue reading “How To Make A Simple MOSFET Tester” →

Send Images To Your Terminal With Rich Pixels

September 13, 2025 by Donald Papp 2 Comments

[darrenburns]’ Rich Pixels is a library for sending colorful images to a terminal. Give it an image, and it’ll dump it to your terminal in full color. While it also supports ASCII art, the cool part is how it makes it so easy to display an arbitrary image — a pixel-art rendition of it, anyway — in a terminal window.

How it does this is by cleverly representing two lines of pixels in the source image with a single terminal row of characters. Each vertical pixel pair is represented by a single Unicode ▄ (U+2584 “lower half block”) character. The trick is to set the background color of the half-block to the upper pixel’s RGB value, and the foreground color of the half-block to the lower pixel’s RGB. By doing this, a single half block character represents two vertically-stacked pixels. The only gotcha is that Rich Pixels doesn’t resize the source image; if one’s source image is 600 pixels wide, one’s terminal is going to receive 600 U+2584 characters per line to render the Rich Pixels version.

[Simon WIllison] took things a step further and made show_image.py, which works the same except it resizes the source image to fit one’s terminal first. This makes it much more flexible and intuitive.

The code is here on [Simon]’s tools GitHub, a repository for software tools he finds useful, like the Incomplete JSON Pretty Printer.

ESP32 Hosts Functional Minecraft Server

September 13, 2025 by Tyler August 3 Comments

If you haven’t heard of Minecraft, well, we hope you enjoyed your rip-van-winkle nap this past decade or so. For everyone else, you probably at least know that this is a multiplayer, open world game, you may have heard that running a Minecraft server is a good job for maxing out a spare a Raspberry Pi. Which is why we’re hugely impressed that [PortalRunner] managed to squeeze an open world onto an ESP32-C3.

Of course, the trick here is that the MCU isn’t actually running the game — it’s running bareiron, [PortalRunner]’s own C-based Minecraft server implementation. Rewriting the server code in C allows it to be optimized for the ESP32’s hardware, but it also let [PortalRunner] strip his server down to the bare essentials, and tweak everything for performance. For example, instead of the multiple octaves of perlin noise for terrain generation, with every chunk going into RAM, he’s using the x and z of the corners as seeds for the psudorandom rand() function, and interpolating between them. Instead of caves being generated by a separate algorithm (and stored in memory), in bareiron the underground is just a mirror-image of the world above. Biomes are just tiled, and sit separately from one another.

So yes, what you get from bareiron is simpler than a traditional Minecraft world — items are simplified, crafting is simplified, everything is simplified, but it’s also running on an ESP32, so you’ve got to give it a pass. With 200 ms to load each chunk, it’s playable, but the World’s Smallest Minecraft Server is a bit like a dancing bear: it’s not about how well it dances, but that it dances at all.

This isn’t the first time we’ve seen Minecraft’s server code re-written: some masochist did it in COBOL, but at least that ran on an actual computer, not a microcontroller. Speaking of low performance, you can’t play Minecraft on an SNES, but you can hide the game inside a cartridge, which is almost as good.

Thanks to [CodeAsm] for the tip. Please refer any other dancing bears spotted in the wild to our tips line.

Continue reading “ESP32 Hosts Functional Minecraft Server” →

Keep Reading, Keep Watching

September 13, 2025 by Elliot Williams 7 Comments

I’ve been flying quadcopters a fair bit lately, and trying to learn some new tricks also means crashing them, which inevitably means repairing them. Last weekend, I was working on some wiring that had gotten caught and ripped a pad off of the controller PCB. It wasn’t so bad, because there was a large SMT capacitor nearby, and I could just piggyback on that, but the problem was how to re-route the wires to avoid this happening again.

By luck, I had just watched a video where someone else was building up a new quad, and had elegantly solved the exact same routing problem. I was just watching the video because I was curious about the frame in question, and I had absolutely no idea that it would contain the solution to a problem that I was just about to encounter, but because I was paying attention, it make it all a walk in the park.

I can’t count the number of times that I’ve had this experience: the blind luck of having just read or seen something that solves a problem I’m about to encounter. It’s a great feeling, and it’s one of the reasons that I’ve always read Hackaday – you never know when one hacker’s neat trick is going to be just the one you need next week. Indeed, that’s one of the reasons that we try to feature not just the gonzo hacks that drill down deep on a particular feat, but also the little ones too, that solve something in particular in a neat way. Because reading up on the hacks is free, and particularly cheap insurance against tomorrow’s unexpected dilemmas.

Turning A Milling Machine Into A Lathe

September 13, 2025 by Aaron Beckendorf 1 Comment

If you’re planning to make a metalworking lathe out of a CNC milling machine, you probably don’t expect getting a position sensor to work to be your biggest challenge. Nevertheless, this was [Anthony Zhang]’s experience. Admittedly, the milling machine’s manufacturer sells a conversion kit, which greatly simplifies the more obviously difficult steps, but getting it to cut threads automatically took a few hacks.

The conversion started with a secondhand Taig MicroMill 2019DSL CNC mill, which was well-priced enough to be purchased specifically for conversion into a lathe. Taig’s conversion kit includes the spindle, tool posts, mounting hardware, and other necessary parts, and the modifications were simple enough to take only a few hours of disassembly and reassembly. The final lathe reuses the motors and control electronics from the CNC, and the milling motor drives the spindle through a set of pulleys. The Y-axis assembly isn’t used, but the X- and Z-axes hold the tool post in front of the spindle.

The biggest difficulty was in getting the spindle indexing sensor working, which was essential for cutting accurate threads. [Anthony] started with Taig’s sensor, but there was no guarantee that it would work with the mill’s motor controller, since it was designed for a lathe controller. Rather than plug it in and hope it worked, he ended up disassembling both the sensor and the controller to reverse-engineer the wiring.

He found that it was an inductive sensor which detected a steel insert in the spindle’s pulley, and that a slight modification to the controller would let the two work together. In the end, however, he decided against using it, since it would have taken up the controller’s entire I/O port. Instead, [Anthony] wired his own I/O connector, which interfaces with a commercial inductive sensor and the end-limit switches. A side benefit was that the new indexing sensor’s mounting didn’t block moving the pulley’s drive belt, as the original had.

The end result was a small, versatile CNC lathe with enough accuracy to cut useful threads with some care. If you aren’t lucky enough to get a Taig to convert, there are quite a few people who’ve built their own CNC lathes, ranging from relatively simple to the extremely advanced.

Design Scanimations In A Snap With The Right Math

September 13, 2025 by Donald Papp 6 Comments

Barrier-grid animations (also called scanimations) are a thing most people would recognize on sight, even if they didn’t know what they were called. Move a set of opaque strips over a pattern, and watch as different slices of that image are alternately hidden and revealed, resulting in a simple animation. The tricky part is designing the whole thing — but researchers at MIT designed FabObscura as a design tool capable not only of creating the patterned sheets, but doing so in a way that allows for complex designs.

The barrier grid need not consist of simple straight lines, and movement of the grid can just as easily be a rotation instead of a slide. The system simply takes in the desired frames, a mathematical function describing how the display should behave, and creates the necessary design automatically.

The paper (PDF) has more details, and while it is possible to make highly complex animations with this system, the more frames and the more complex the design, the more prominent the barrier grid and therefore the harder it is to see what’s going on. Still, there are some very nice results, such as the example in the image up top, which shows a coaster that can represent three different drink orders.

We recommend checking out the video (embedded below) which shows off other possibilities like a clock that looks like a hamster wheel, complete with running rodent. It’s reminiscent of this incredibly clever clock that uses a Moiré pattern (a kind of interference pattern between two elements) to reveal numerals as time passes.

We couldn’t find any online demo or repository for FabObscura, but if you know of one, please share it in the comments.

Continue reading “Design Scanimations In A Snap With The Right Math” →