Mesh2Cad Automates Re-Modelling

It’s happened to all of us, we find an STL that would just about solve our problems, but the mesh isn’t quite right. Sometimes mesh-editing is good enough, other times you need to rebuild the mesh in a proper CAD environment to get what you need. In that latter case, [Emir Mrkaljevic]’s Mesh2Cad program could save you a whole lot of work, because it does exactly what it says on the tin: turns a mesh to a CAD file.

Even better, [Emir] doesn’t pick the CAD format for you. Sure, it does STEP, but you can also go straight to FreeCAD, CadQuerry or OpenSCAD with these handy scripts. Well, technically the FreeCAD version generates a macro to make the object rather than a .FCSTD, but that’s still pretty handy. Scripts is the right word for mesh2cad, because the whole thing is python and just a pip install mesh2cad away from living on your machine. Of course you don’t need to use pip since the whole thing is on GitHub and available for your eyeballs to audit. Speaking of audit, the scripts apparently check their own work and only give you CAD if they can approximate the mesh within tolerance.

Now there are limits here, if you think it sounds too good to be true. You’re limited to things that can be made of the sort of primitive manipulation OpenSCAD usually deals in — no organic shapes, free-flowing curves, or the like. If it’s a box or a bracket with holes, fillets and chamfers, though, this tool might save you a couple minutes recreating it.

If you prefer to do it yourself or have one of those annoyingly-organic meshes this tool won’t touch, we have a guide for what to do when an STL needs some tweaking.

Tracking Down A Mystery Beep By Giving A Coding Agent A Few Ears

[Simon Willison] recently used a coding agent in an unusual way. A software system temporarily used the microphones on devices scattered around the room to triangulate the source of a mysterious, intermittent beep coming from within one of the many boxes in the room.

The main part of the system is a Python web server, and the listeners can be any old devices one might have hanging around. Scan a QR code, and the device becomes a listening post by leveraging the Web Audio API. With listeners spread around the room, the system has everything it needs to patiently wait, listen, and zero in on the mystery beep. The culprit? An old carbon monoxide detector, buried in a box and emitting a low battery chirp.

That’s neat, but what this project really demonstrates is the benefit of hacking together a way for a coding agent to actually sense the real world, the better for it to design a solution to a physical problem.

The ad-hoc framework of web-based listeners allowed [Simon] to give the agent the ability to gather audio data on its own to refine and recalibrate its approach during development, without any need for him to record audio and pass it on manually.

It’s a bit reminiscent of this WiFi analyzer connected to an AI model, a project that hints at the possibilities of a physical tool that can be steered by an agent. Check out the GitHub repository for beep-locator if you’d like a closer look at the code itself.

Sheet music is displayed on a screen, with the label "AIR" in the center top, and "Bach" to the right.

Reverse Engineering Score Perfect To Rescue Its Files

There are myriad challenges associated with data preservation – bit rot, loss of metadata, and hardware failures, among others – but one of the hardest is making sure that the data remains usable as software goes out of date. [Maarten Tromp]’s father, for instance, had been using the Score Perfect music notation program for years, but since development ceased in 2012, the files would eventually need to be transferred to more modern software. To do this, [Maarten] undertook a four-year project to reverse-engineer the structure of Score Perfect’s files.

Score Perfect was first released in 1990 for Atari and later ported to Windows, and after version four, it switched to a different file format. It had the option to export to MusicXML, but it only exported notes, not chords, lyrics, or other important details. [Maarten] first tried disassembling the program itself to find the file structure; he had hoped that the Visual Basic code might have been compiled to P-code, which is relatively easy to disassemble, but it had been compiled to native code. Interestingly, through version four, the program had been written for Atari and ran in Windows through a simple emulator. It wasn’t fully rewritten for Windows until later. After some investigation into the file-export function with Ghidra, he moved on to reverse-engineering the file format itself.

This consumed the majority of the project’s time. To investigate the file’s structure, [Maarten] would start by creating an empty file in the program, make one change, and compare the difference in the file written. This gradually revealed the organization of information — the file was arranged into blocks containing different kinds of information, such as measures and notes, and tags, which provided supplemental information. Once again, incremental changes revealed the function of most of these, and [Maarten] was eventually able to write a translation program to export Score Perfect files to MusicXML.

We’ve previously seen a similar effort to reverse-engineer the Altium file format. At least in these cases, though, all the necessary information is contained in the files, unlike the reverse-engineering often necessitated by STL files.

X Window System On The ESP32

There are a lot of things you can do with an Xserver, but run it on a microcontroller? Well, if that microcontroller is an ESP32-S3, [Sergey Zorin]– and Claude– have got you covered with Woodland X11, a full-featured port of everyone’s favourite XServer.

Now, it is just the core Xserver with no extensions, and currently targeted specifically at the Elecrow CrowPanel Advance 4.3″, a device that packages an ESP32-S3-N16R8 with an 800×480 RGB565 IPS panel and GT911 touch. In this implementation, your finger is the Xcursor. There’s even two-finger scroll implemented, though no keyboard. As you can see in the demo video embedded below, it works well enough for those oldschool X applications like xclock, xcalc and– crucially!– xeyes. What’s the point of an Xserver without googly eyes, anyway?

In reality, you’re not likely to set this up just for Xeyes, but the idea of having bringing Linux applications to a little display via WiFi or — as in the video– wired connection has no limit of use cases. Try that with Wayland!

Considering X11’s vintage, it is perhaps not surprising that it fits on the ESP32-S3, a chip we’ve seen emulate an entire 386 PC before– a PC that could run an Xserver, for you youngun’s.

Thanks to [Sergey] for the tip!

Continue reading “X Window System On The ESP32” →

A Desktop OS For The ESP32-P4

The ESP32-P4 is Espressif’s high-end application processor, with two blistering fast RISC-V cores for a surprisingly reasonable price. As it’s a very capable computer in its own right, there have been a range of operating systems made for it. Latest among them is [Jthwho]’s BMDS, for Bare Metal Do Stuff, which targets an Olimex board.

At its heart is the FreeRTOS kernel we’ve seen in so many other similar projects, but on top is an OS which is described as being like DOS in its one-user minimally intrusive operation. It runs ELF binaries, and has some POSIX compliance, with BusyBox being a port. Perhaps most noticeable is its GUI, which provides a very slick desktop straight out of the late 1990s.

We can see that had this appeared as a contemporary of Amigas, 68k Macs, and Windows 3.x, it would have immediately been a real contender. But the question is, does such an OS have a niche here in 2026? We think it might, as this processor is slowly establishing itself in a new genre of powerful machines aimed at hackers and tinkerers. Either way it’s an impressive achievement, and we look forward to seeing it develop over time.

Watching The Watchers

Although it used to be a much more rare event, now almost any time at dawn or dusk, provided clear weather, a human observer can walk outside, look up, and spot an artificial satellite passing overhead. This has caused some consternation among astronomers who have another source of pollution to deal with in their data, but has benefited society in other ways such as more reliable internet and better weather predictions. To keep an eye on what exactly is passing overhead, take a look at this tool built by [Armaan].

The browser-based satellite tracker uses simplified perturbations models (SGP4) to model the passes of every satellite that has passed a given location on Earth in the past seven days. The modeling is all done locally within the user’s browser, and can even be self-hosted through a fairly simple method that involves forking the project with a tool called Vercel. Not only does this tool find the satellite passes for that given location, though, but it also automatically downloads any imagery that those satellites sent back down to Earth.

The project itself is open source, so users can engage with the code without using Vercel if they choose. Beyond just checking out what happened to fly overhead in the last few days and checking out weather data without needing your own satellite dish to download the data yourself, this could also be useful for radio operators looking to make contacts with satellite repeaters or those wanting to keep tabs on crewed satellites like the International Space Station while it still remains in orbit.

The Goat Emoji Is 100% Valid Machine Code, And It Doesn’t Stop There

Did you know emojis can be executables? Well, they are if you treat them like Intel 8088 or 8086 machine code, anyway. [GloriousCow] shared this clever revelation, demonstrating that executable programs could be created entirely from emojis. To really appreciate why, it’s necessary to take a small step back.

It all started when [GloriousCow] happened to notice, entirely by chance, that 🐐 (the goat emoji) was F0 9F 90 90. Anyone familiar with x86 assembly language probably recognizes 90h as nop,  or null operation, or “spend a cycle doing nothing”. What about F0 and 9F? Together they are lock lahf (assert the bus lock signal then copy some status flags into register AH) which, on an 8088 and 8086, essentially does nothing.

This means the goat emoji (F0 9F 90 90) is 100% technically valid machine code. It doesn’t do anything, but here’s where it gets even more interesting.

A short string of emojis is machine code that writes HELLO (lower right) by writing directly to video memory.

There are loads of emojis, and many of them start with F0 9F followed by two more bytes, and many of those other two-byte combinations are surely also valid machine code. Could one create a meaningful executable program consisting entirely of emojis? The answer is yes, and [GloriousCow] crafted a simple Hello World program to demonstrate.

The simple program looks like this: 🐸☺️🐰🐎♐🗃️🧯🧯🧯🐮💗🦮🪏♐🐰🐹🗃️🧯🧯🧯🧯💗🪗🧯😗🧮🫪😗🧮😗🐮😪😔⭐. Save that string of emojis to a file, give it a .com extension, and run it in DOSBox with CPU type set to 8086. It’ll print HELLO at the bottom-right of the screen by writing directly to video memory.

There are loads more details on the original blog post, including plenty of resources and tips for writing your own executables with emojis. There’s also a much more involved VGA demo program made from emojis, so give it a look.

Some of you may be aware that ASCII characters can also be used in a similar way (and more flexibly, since they are not four-byte combinations like emojis). This was used in BASIC programs as a way to cleverly embed machine code in things like REM statements, creating odd-looking code that did things in BASIC that shouldn’t have been possible.