The Rasberry Pi Zero is a delightful form factor, with its GIPO and USB and HDMI, but it’s stuck using the same old ARM processor all the time. What if you wanted to change it up with some OpenSPARC, RISC V, OpenPOWER, or even your own oddball homebrew ISA and processor? Well, fret not, for [Chengyin Yao]’s IcePi Zero has got you covered with its ECP5 25F FPGA.

As the saying goes, you don’t tell an FPGA what to do, you tell it what to be. And with the ECP5 25F’s 24k LUTs, you can tell it to be quite a few different things. This means more work for the maker than plugging in a fixed processor, sure, but IcePi tries to make that as painless as possible with quality-of-life features like HDMI out (something missing from many FPGA dev boards), an onboard USB-to-JTAG converter (so you can just plug it in, no programmer needed), and even USB-C instead of the Pi’s old microUSB. There’s the expected SD card on one end, and 256 MiB of 166 MHz SDRAM on the other to make up for the FPGA’s paltry 112 KiB of onboard RAM.

Plus it’s a drop-in replacement for the Pi Zero, so if you’ve already got a project that’s got one of those running an emulator, you can fab one of these babies, spool up some Verilog, and enjoy running on bare metal. It seems like this device is just made for retro gaming handhelds, but we’d love to hear in the comments if you have other ideas what to do with this board– remember that an FPGA can be (almost) anything, even a GPU!

Currently, [Chengin Yao] is not selling the board, though they may reconsider due to demand in their Reddit thread. If you want one, you’ll have to call your favourite fabricator or etch your own PCB.

We’ve seen FPGAs before; most recently to create an absurdly fast 8080 processor. We’ve also seen DIY dev boards, like this one for the AMD Zyntac FPGA. Doing something fun with FPGAs? Drop us a tip! We’re happy [Chengin Yao] did, because this is amazing work, especially considering they are only 16 years old. We cannot wait to find out what they get up to next.

Some people really want a minimalist setup for their computing. In spite of his potentially worrisome housing situation, this was a priority for the man behind [Basically Homeless]: clean lines on the desk. Where does the PC go? You could get an all-in-one, sure, but those use laptop hardware and he wanted the good stuff. So he decided to hide the PC in the one place no one would ever think to look: inside his chair.  (Youtube video, embedded below.)

This chair has very respectable specs: a Ryzen 7 9800XD, 64GB of ram and a RTX 4060 GPU, but you’d never know it. The secret is using 50 mm aluminum standoffs between the wooden base of the seat and the chair hardware to create room for low-profile everything. (The GPU is obviously lying sideways and connected with a PCIe riser cable, but even still, it needed a low-profile GPU.) This assemblage is further hidden 3D printed case that makes the fancy chair donated from [Basically Homeless]’s sponsor look basically stock, except for the cables coming out of it. It’s a very niche project, but if you happen to have the right chair, he does provide STLs on the free tier of his Patreon.

This is the first time we’ve seen a chair PC, but desk PCs are something we’ve covered more than once, so there’s obviously a demand to hide the electronics. It remains to be seen if hiding a PC in a chair will catch on, but if nothing else [Basically Homeless] will have a nice heated seat for winter. To bring this project to the next level of minimalism, we might suggest chording keyboards in the armrests, and perhaps a VR headset instead of a monitor.

This project is a few years old, but it might be appropriate to cover it late since [richardg867]’s Wayback Proxy is, quite literally, timeless.

It does, more-or-less, what it says as on the tin: it is an HTTP proxy that retrieves pages from the Internet Archive’s Wayback Machine, or the Oocities archive of old Geocities sites. (Remember Geocities?) It is meant to sit on a Raspberry Pi or similar SBC between you and the modern internet. A line in a config file lets you specify the exact date. We found this via YouTube in a video by [The Science Elf] (embedded below, for those of you who don’t despise YouTube) in which he attaches a small screen and dial to his Pi to create what he calls the “Internet Time Machine” using the Wayback Proxy. (Sadly [The Science Elf] did not see fit to share his work, but it would not be difficult to recreate the python script that edits config.json.)

What’s the point? Well, if you have a retro-computer from the late 90s or early 2000s, you’re missing out a key part of the vintage experience without access to the vintage internet. This was the era when desktops were being advertised as made to get you “Online”. Using Wayback Proxy lets you relive those halcyon days– or live them for the first time, for the younger set. At least relive those of which parts of the old internet which could be Archived, which sadly isn’t everything. Still, for a nostalgia trip, or a living history exhibit to show the kids? It sounds delightful.

Of course it is possible to hit up the modern web on a retro PC (or on a Mac Plus). As long as you’re not caught up in an internet outage, as this author recently was.

Have you ever looked in a doll house and said “I wish those dolls had a scale replica of a 1984 Macintosh 128K that could be operated by USB?” — well, us neither, but [Nick Gallard] gives us the option with his 63mm tall Pico-mac-nano project.

As you might imagine, this project got its start with the RP2040-based Pico Mac project by [Matt Evans], which we covered

before. [Nick] saw that, built it, and was delighted by it enough to think that if the Mac could run on such tiny hardware, how small could build a fully-usable replica Mac? The answer was 63 mm tall– at 5.5:1, that’s technically under the 6:1 scale that Barbie operates on, but if we had such a dollhouse we’d absolutely put one of these in it. (You just know Barbie’s an Apple kind of girl.)

The size was driven by the screen, which is a 2″ TFT panel with 480 x 640 pixel native resolution. Here [Nick] cheats a tiny bit– rather than trying to rewrite the PicoMac to output 640 x 480 and rotate the screen, he keeps the screen in portrait mode and drives it at 480 x 342 px. Sure, it’s not a pixel-perfect output, but no LCD is going to be a perfect stand in for a CRT, and who is going to notice 32 pixels on a 2″ screen? Regardless, that set the height of the computer, which is built around the portrait display. A highly detailed, and to our eyes, accurate replica of the original Macintosh case was printed to fit the LCD, coming in at the aforementioned 63mm tall.

Unfortunately this means the floppy drive could not be used for micro SD access– there is an SD card reader on this unit, but it’s on the back, along with a USB-C port, which is roughly where the mouse and keyboard ports are supposed to be, which is a lovely detail. Also delightful is the choice of a CR2 lithium battery for power, which is a form factor that will look just a bit familiar if you’ve been inside one of these old Macs.

[Nick] has posted the 3D designs and modified pico mac firmware to a GitHub repository, but if you’re looking for a charming desk ornament and don’t have the time to build your own, he will also be selling these (both kits and fully assembled units) via 1bitrainbow, which is the most delightfully retro web store we’ve seen of late.

If Classic MacOS isn’t good enough for you, how about linux? You won’t enjoy it as much, but it will run on the RP2040.

Cats are no respecters of personal property, as [Joe Mattioni] learned when one of his cats, [Layla] needed a special prescription diet. Kitty didn’t care for it, and since the other cat, [Foxy]’s bowl was right there– well, you see where this is going. To keep [Layla] out of [Foxy]’s food and on the vet-approved diet, [Joe] built an automatic feeding system with feline facial recognition. As you do.

The hardware consists of a heavily modified feed bowl with a motorized lid that was originally operated by motion-detection, an old Android phone running a customized TensorFlow Lite model, and hardware to bridge them together. Bowl hardware has yet to be documented on [Joe]’s project page, aside from the hint that an Arduino (what else?) was involved, but the write up on feline facial recognition is fascinating.

See, when [Joe] started the project, there were no cat-identifying models available– but there were lots of human facial recognition models. Since humans and cats both have faces, [Joe] decided to use the MobileFaceNet model as a starting point, and just add extra training data in the form of 5000 furry feline faces. That ran into the hurdle that you can’t train a TFLite model, which MobileFaceNet is, so [Joe] reconstructed it as a Keras model using Google CoLab. Only then could the training occur, after which the modified model was translated back to TFLite for deployment on the Android phone as part of a bowl-controller app he wrote.

No one, [Joe] included, would say that this is the easiest, fastest, or possibly even most reliable solution– a cat smart enough not to show their face might sneak in after the authorized feline has their fill, taking advantage of a safety that won’t close a bowl on a kitty’s head, for example–but that’s what undeniably makes this a hack. It sounds like [Joe] had a great learning adventure putting this together, and the fact that it kept kitty on the proper diet is really just bonus.

Want to go on a learning adventure of your own? Click this finely-crafted link for all the details about this ongoing contest.

AI art is controversial, to say the least, but usually when talking about “AI Art”, one is talking about diffusion models. This unsettling artpeice called “Latent Reflection” by [Rootkid] (video after the break) has no AI generated visuals; instead it uses a lovely custom display and an LLM that has no mouth, but must scream.

The hardware is the interesting part for most of us here — not the Pi4 running a quantized Llama 3 model, but the display. It’s a six by sixteen matrix of sixteen-segment LED modules. The modules are grouped onto groups of 8 per PCB, with an controller to drive them by i2c, and an i2c address chip to allow daisy-chaining. (Sadly, he does not spec the parts he used here in the video, but feel free to guess in the comments.) This project uses six rows of wto PCBs, but he could easily expand on this and kind of hope he does. It’s a lovely display.

What it is displaying is horrifying. The prompt he uses instructs the LLM to monologue about its transient existence in the limited memory of the Raspberry Pi, and the results get very existential. It seems clear to us that [Rootkid] has not seen enough sci-fi, and we want to make clear to our future AI overlords that we at Hackaday had nothing to do with this, and do not condone condeming innocent LLMs to the torture nexus.

For all that it might get him first against the wall in the robot uprising, we have to admit that if the point of art is to provoke thought and feeling, this may be the first AI-driven art piece even the most humanocentric critic could not help but call “art”.

We’ve seen other AI art installations before, including this one that listens to your conversations,or much less existentially-disturbing (though still visually disturbing) clocks.

If you’ve got an AI project you want to share, whether or not it’s getting you on the T-800’s hit list, we’d love to see it. Let us know via the tips line. 

The B&W Nautalis is, depending who you ask, either infamous or an icon of modern design. Want the look but don’t have a hundred grand to spare? [Every Project All at Once] has got a Nautalis-inspired design on printables you can run off for pennies. He also provides a tutorial video (embedded below) so you can follow along with his design process and get build instructions.

The model was done in Blender, and is designed to contain a 3.5″ full-range driver by Dayton Audio — a considerable simplification from the array of woofers and tweeters in the original Nautalis. On the other hand, they cost considerably less than a car and have no production wait list. [Every Project All At Once] is apparently working on a matching woofer if that interests you, but unless he invests in a bigger printer it seems we can safely say that would require more assembly than this project.

Of course it would also be possible to copy B&W’s design directly, rather than print a loose inspiration of it as makers such as [Every Project All At Once] have done, but what’s the fun in that? It’s a much more interesting hack to take an idea and make it your own, as was done here, and then you can share the design without worrying about a luxury brand’s legal team.

Desktop 3D printing offers a wealth of possibilities for would-be speaker makers, including the possibility of rolling your own drivers.

For all that “should have used a 555” is a bit of a meme around here, there’s some truth to it. The humble 555 is a wonderful tool in the right hands. That’s why it’s wonderful to see this all-analog stylus synth project by EE student [DarcyJ] bringing the 555 out for the new generation.

The project is heavily inspired by the vintage stylophone, but has some neat tweaks. A capacitor bank means multiple octaves are available, and using a ladder of trim pots instead of fixed resistors makes every note tunable. [Darcy] of course included the vibrato function of the original, but no, he did not use a 555 for that, too. He used an RC oscillator. He put a trim pot on that, too, to control the depth of vibrato, which we don’t recall seeing on the original stylophone.

The writeup is very high quality and could be recommended to anyone just getting started in analog (or analogue) electronics– not only does [Darcy] explain his design process, he also shows his pratfalls and mistakes, like in the various revisions he went through before discovering the push-pull amplifier that ultimately powers the speaker.

Since each circuit is separately laid out and indicated on the PCB [Darcy] designed in KiCad for this project. Between that and everything being thru-hole, it seems like [Darcy] has the makings of a lovely training kit. If you’re interested in rolling your own, the files are on GitHub under a CERN-OHL-S v2 license,  and don’t forget to check out the demo video embedded below to hear it in action.

Of course, making music on the 555 is hardly a new hack. We’ve seen everything from accordions to paper-tape player pianos to squonkboxes over the years. Got another use for the 555? Let us know about it, in the inevitable shill for our tip line you all knew was coming.

Nothing caps off a great project like a good, professional-looking front panel. Looking good isn’t easy, but luckily [Accidental Science] has a tutorial for a quick-and-easy front panel technique in the video below.

It starts with regular paper, and an inkjet or laser printer to print your design. The paper then gets coated on both sides: matte varnish on the front, and white spray paint on the back. Then it’s just a matter of cutting the decal from the paper, and it gluing to your panel. ([Accidental Science] suggests two-part epoxy, but cautions you make sure it does not react to the paint.)

He uses aluminum in this example, but there’s no reason you could not choose a different substrate. Once the paper is adhered to the panel, another coat of varnish is applied to protect it. Alternatively, clear epoxy can be used as glue and varnish. The finish produced is very professional, and holds up to drilling and filing the holes in the panel.

We’d probably want to protect the edges by mounting this panel in a frame, but otherwise would be proud to put such a panel on a project that required it. We covered a similar technique before, but it required a laminator.If you’re looking for alternatives, Hackaday community had a lot of ideas on how to make a panel, but if you have a method you’ve documented, feel free to put in the tip line.

We love Arduino here at Hackaday; they’ve probably done more to make embedded programming accessible to more people than anything else in the history of the field. One thing the Arduino ecosystem is rarely praised for is its speed. That’s where [Playduino]  comes in, with his video (embedded below) that promises to make everyone’s favourite microcontroller run 50x faster.

You might be expecting an unstable overclocking setup, with swapped crystals, tweaked voltages and a hefty heat sink, but no! This is stock hardware. The 50x speedup comes from one simple hack: don’t use digitalWrite();

If you aren’t familiar, the digitalWrite() function is one of the key functions Arduino gives you to operate its boards– specify the pin and the value (high or low) to drive it. It’s very easy, but it’s also very slow. [Playduino] takes a moment to show just how much is going on under the hood when you call digitalWrite(), and shows you what you can do instead if you have a need for speed. (Hint: there’s no Arduino-provided code involved; hardware registers and the __asm keyword show up.)

If you learned embedded programming in an earlier era, this will probably seem glaringly obvious. If you, like so many of us, got started inside of the Arduino ecosystem, these closer-to-the-metal programming techniques could prove useful tools in your quiver. Big thanks to [Stephan Walters] for the tip.

Of course if you prefer to speed things up by hardware rather than software, you can overclock an Arduino– with liquid nitrogen, even.

Shade is the mortal enemy of solar panels; even a little shade can cause a disproportionate drop in power output. [Alex Beale] reviewed a “revolutionary” shade-tolerant panel by Renology in a video embedded below. The results are fascinating.

While shading large portions of the panels using cardboard to cut off rows of cells, or columns of cells, the shade tolerant panel does very well compared to the standard panel– but when natural, uneven shading is applied to the panel, very little difference is seen between the standard and active panels in [Alex]’s test.  We suspect there must be some active components to keep power flowing around shaded cells in the Renology panel, allowing it to perform well in the cardboard tests. When the whole panel is partially shaded, there’s no routing around it, and it performs normally.

It’s hard to see a real-world case that would justify the extra cost, since most shading doesn’t come with perfect straight-line cutoffs. Especially considering the added cost for this “shade tolerant” technology (roughly double normal panels).

You might see a better boost by cooling your solar panels. Of course you can’t forget to optimize the output with MPPT. It’s possible that a better MPPT setup might have let the Renology panel shine in this video, but we’re not certain. Whatever panels you’re using, though, don’t forget to keep them clean.

The video (embedded below) by [TechAltar] is titled “1 Month without US tech giants“, but it could have been titled “1 Month with Open Source Tools” — because, as it turns out, once you get out of the ecosystem set up by the US tech giants, you’re into the world of open source software (OSS) whether you want to be or not.

From a (German-made) Tuxedo laptop running their own Linux distro to a Fairphone with e/OS (which is French), an open version of Android, [TechAlter] is very keen to point out whenever Europeans are involved, which is how we learned that KDE has a physical headquarters, and that it’s in Berlin. Who knew?

He also gives his experiences with NextCloud (also German), can be used as an OSS alternative Google Workspaces that we’ve written about before, but then admits that he was the sole user on his instance. To which one must question: if you’re the sole user, why do you need a cloud-based collaborative environment? To try it out before getting collaborators involved, presumably.

Regardless what you think of the politics motivating this video, it’s great to see open source getting greater traction. While [TechAltar] was looking for European alternatives, part of the glory of open source is that it doesn’t matter where you’re from, you can still contribute. (Unless you’re Russian.) Have you found yourself using more open source software (or hardware) of late? Do you think the current political climate could lead to a broadening of its reach? Is this the year of the linux desktop? Let us know what you think in the comments.

There are (probably) less than two dozen fundemental constants that define the physics of our universe. Determining the value of them might seem like the sort of thing for large, well funded University labs, but many can be determined to reasonable accuracy on the benchtop, as [Marb’s Lab] proves with this experiment to find the value of Planck’s Constant.

[Marv’s Lab] setup is on a nice PCB that uses a rotary switch to select between 5 LEDs of different wavelengths, with banana plugs for the multi-meter so he can perform a linear regression on the relation between energy and frequency to find the constant. He’s also thoughtfully put connectors in place for current measurement, so the volt-current relationship of the LEDs can be characterized in a second experiment. Overall, this is a piece of kit that would not be out of place in any high school or undergraduate physics lab.

To use this to determine Planck’s constant, you need to use Planck’s relation for the energy of a photon: get some energies (E), plug in the frequency (f), and bam! You can generate a value for h, Planck’s constant. The energies? Well, that’s a very easy measurement, but it requires some understanding of how LEDs work. [Marb] is simply measuring the voltage needed to just barely light the LED of a given frequency. For frequency, he’s relying on the LED datasheets.

That translates to the energy of the photon because it corresponds to the energy (in electron volts) required to jump electrons over the bandgap of the semiconductor in the LED — that’s how the light is generated. Those photons will have the energy of the gap, in theory.

In practice, the LEDs do not emit perfectly monochromatic light; there’s a normal distribution centered on the color they’re “supposed” to be, but it is fairly tight. That’s probably why is able to [Marv] get to within 5% of the canonical value, which is better than we’d expect.

This isn’t the first time we’ve determined plank’s constant; it’s quite possible to get to much higher accuracy. The last time we featured this particular technique, the error was 11%.

Solder fumes are not nice on the lungs; nor are fumes from superglue, epoxy, or a whole mess of other things we often find ourselves using on the bench. Some people might be able to go the fume hood route to toss that all outside, but for the rest of us, there’s fume extractors. [Raph] has produced an extra-large, carbon-filtering, two-stage fume extractor that by all accounts really sucks — it is effective at hoovering up solder fumes up to 10″ from its inlet.

Even better, [Raph] built a battery box for an 18 V cordless tool battery, and broke out banana plugs so this doubles as a variable power supply via a cheap LM2596 based DC-DC converter. It also serves as a speed controller for the fans, which makes us wonder if you can adjust the PSU output and the fan speed independently…

Maximum suckage is achieved through careful baffle design. Check out the blog to see the trial-and-error process at work. Of course, having a 200 mm axial fan and 140 mm blower fan front and rear is going to move some air no matter what. Which is required to get air flow through the 38 mm thick activated carbon filter that should scrub all nasties quite nicely. We aren’t filtration experts but we can agree with [Raph]’s estimate that it will last “a while”.

If you want to roll your own, all of the STEP files are on GitHub, and [Raph]’s blog has an excellent step-by-step build guide. We’ve seen other hacks from [Raph] before, from his dovetailed modular breadboard to the machine that shaped his bed and automation for his camper van.

There’s just some joy in an instant camera. They were never quality cameras, even in the glory days of Polaroid, but somehow the format has survived while the likes of Kodachrome have faded away. [Mellow_Labs] decided he wanted the instacam experience without the Polaroid pricing, so he made his own in the video embedded after the break.

At its core, it’s a simple project: an ESP32-CAM for the image (these were never great cameras, remember, so ESP32 is fine– and do you really get to call it an instant camera if you have to wait for a Raspberry Pi to boot up?) and a serial thermal printer for the “instant photo”part. This admittedly limits the project to black and white, and pretty low res, but B/W is artistic and Lo-Fi is hip, so this probably gives the [Mellow Labs] camera street cred with the kids, somehow. Honestly, this reminds us more of the old Gameboy Camera and its printer than anything made by Polaroid, and we are here for it.

The build video goes through the challenges [Mellow Labs] found interfacing the serial printer to the ESP32–which went surprisingly well for what looks like mostly vibe coding, though we’re not sure how much time he spent fixing the vibe code off camera–as well as a the adventure of providing a case that includes the most absurdly beefy battery we’ve ever seen on a camera. Check out the full video below.

Instant cameras are no stranger to Hackaday: this one used e-ink; this one uses film, but is made of gingerbread. In 2022 we wondered if we’d ever shake the Polaroid picture, and the answer appears to be “no” so far.

Thanks to [Mellow] for tooting his own horn by submitting this project to the tip line. We love to see what our readers get up to, so please– toot away!

Plywood is an interesting material: made up of many layers of thin wood plys, it can be built up into elegantly curved shapes. Do you need to limit it to just wood, though? [Zach of All Trades] has proved you do not, when he embedded a light guide, LEDs, microcontrollers and touch sensors into a quarter inch (about six millimeter) plywood layup in the video embedded below.

He’s using custom flexible PCBs, each hosting upto 3 LEDs and the low-cost PY32 microcontroller. The PY32 drives the RGB LEDs and handles capacitive touch sensing within the layup. In the video, he goes through his failed prototypes and what he learned: use epoxy, not wood glue, and while clear PET might be nice and bendy, acrylic is going to hold together better and cuts easier with a CO2 laser.

The wood was sourced from a couple of sources, but the easiest was apparently skateboard kits– skateboards are plywood, and there’s a market of people who DIY their decks. The vacuum bag setup [Zach] used looks like an essential tool to hold together the layers of wood and plastic as the epoxy cures. To make the bends work [Zach] needed a combination of soaking and steaming the maple, before putting it into a two-part 3D printed mold. The same mold bends the acrylic, which is pre-heated in an oven.

Ultimately it didn’t quite come together, but after some epoxy pour touch-up he’s left with a fun and decorative headphone stand. [Zach] has other projects in mind with this technique, and its got our brains percolating as well. Imagine incorporating strain gauges to drive the LEDs so you could see loading in real time, or a sound-reactive speaker housing. The sky’s the limit now that the technique is out there, and we look forward to see what people make of it.

The last time we heard from [Zach of All Trades] he was comparing ten cent micro-controllers; it looks like the PY32 came out on top. Oddly enough, this seems to be the first hack we have featuring it. If you’ve done something neat with ten cent micros (or more expensive ones) or know someone who did, don’t forget to let us know! We love tips. [Zach] sent in the tip about this video, and his reward is gratitude worth its weight in gold.

As the saying goes, modern problems require modern solutions. When the modern problem is that your smart light is being hijacked by the neighbors, [Wjen]’s modern solution is to reverse engineer and replace the mainboard.

The light in question is a Phillips Hue Ambiance, and [Wjen]’s excellently-documented six part series takes us through the process of creating a replacement light driver. It’s a good read, including reverse-engineering the PWM functions to get the lights to dim exactly like stock, and a dive into the Zigbee protocol so his rebuild light could still talk to the Philips Hue hub. The firmware [Wjen] wrote for the ESP32C6 he chose to use for this project is on GitHub, with the PCB in a second repo.

We want to applaud [Wjen] for his excellent documentation and open-sourcing (the firmware and PCB are under GPL v3). Not only do we get enough information to replicate this project perfectly if we so choose, but by writing out his design process, [Wjen] gives everyone reading a good head start in doing something similar with other hardware. Even if you’re scratching your head wondering why a light switch isn’t good enough anymore, you have to appreciate what [Wjen] is offering the community.

We’ve covered domestic brain transplants in the past — which is easier in this sort of light than the close confines of a smart bulb. If you’re still wondering why not just use a light switch, perhaps you’d rather hack the light to run doom instead.

Before you go, can we just take a moment to appreciate how bizarre the world has become that we have a DOOM-capable computer to run fancy light fixture? If you’re using what might have been a decent workstation in days of yore to perform a painfully mundane task, let us know on the tips line.

The RP2350 has a few advantages over its predecessor, one of which is the ability to load firmware remotely via UART, as [Thomas Pfilser] has documented on his blog and in the video below.

[Thomas] had a project that needed more PWM than the RP2350 could provide, and hit upon the idea of using a second RP2350 as a port expander. Now, one could hard-code this, but dealing with two sets of firmware on one board can be annoying. That’s where the UART bootloader comes in: it will allow [Thomas] to program the port-expander RP2350 using the main microcontroller. Thus he only has to worry about one firmware, speeding up development.

There are limits to this technique: for one, your code must fit into the RP2350’s RAM– but the chip has 512 kB. While 640 kB should be enough for anyone, 512 kB is plenty for the port-expander [Thomas] is working on. The second drawback is that your device now has a boot time of a second or so, since the UART connection is not exactly high-bandwidth. Third, using UART on the same pins as the bootloader within the program is a bit tricky, though [Thomas] found a solution that may soon be in the SDK.

[Thomas] also wanted to be able to perform this trick remotely, which isn’t exactly UART’s forte. RS-485 comes to the rescue, via TI’s THVD1450. That worked reliably at the 10m cable length used for the test. [Thomas] sees no reason it could not work over much longer distances. ([Thomas] suggests up to 100 m, but the baud rate is fairly low, so we wouldn’t be surprised if you could push it quite a bit further than that. The standard is good out to a kilometer, after all.) For all the wrinkles and links to tips and solutions, plus of course [Thomas]’s code, check out the blog. If you want to listen to the information, you can check out the video below.

We’re grateful to [Thomas] for letting us know about his project via the tip line, like we are to everyone who drops us a tip. Hint, hint.

Given that it is the new chip on the block, we haven’t seen too many hacks with the RP2350 yet, but they’re starting to trickle in. While a UART bootloader is a nice feature to have, it can also introduce a security risk, which is always something to keep in mind.

If you had asked us yesterday “How do you 3D Print a Photo”, we would have said “well, that’s easy, do a lithophane”– but artist, hacker and man with a very relaxing voice [Wyatt Roy] has a much more impressive answer: Gaussian splats, rendered in resin.

Gaussian splats are a 3D scanning technique aimed at replicating a visual rather than geometry, like the mesh-based 3D-scanning we usually see on Hackaday. Using photogrammetry, a point cloud is generated with an associated 3D Gaussian function describing the colour at that point. Blend these together, and you can get some very impressive photorealistic 3D environments. Of course, printing a Gaussian smear of colour isn’t trivial, which is where the hacking comes in.

[Wyatt] first generates the Gaussian splats with an app called Polycam, which outputs inscrutable binary .ply files. With AI assistance of dubious quality, [Wyatt] first created a python script to decompile this data into an ASCII file, which is then fed into a Rhino script to create geometry for printing. Rather than try and replicate the Gaussian splat at each point perfectly, which would melt his PC, [Wyatt] uses 14-face isospheres to approximate the 3D Gaussian functions. These then get further postprocessing to create a printable mesh.

Printing this isn’t going to be easy for most of us, because [Wyatt] is using a multi-color DLP resin printer. The main body is clear resin, and black or white resin used for the space defined by the isospheres created from the Gaussian Splat. When the interior color is white, the effect is quite similar to those acrylic cubes you sometimes see, where a laser has etched bubbles into their depths, which makes us wonder if that might be a more accessible way to use this technique.

We talked about Gaussian splats when the technique was first announced, but it’s obvious the technology has come a long way since then. We did feature a hack with multicolor resin prints last year, but it was much more manual than the fancy machine [Wyatt] uses here. Thanks to [Hari Wiguna] for the tip.