Commercial 3D printers keep getting faster and faster, but we can confidently say that none of them is nearly as fast as [Jan]’s Minuteman printer, so named for its goal of eventually printing a 3DBenchy in less than a minute. The Minuteman uses an air bearing as its print bed, feeds four streams of filament into one printhead for faster extrusion, and in [Jan]’s latest video, printed a Benchy in just over two minutes at much higher quality than previous two-minute Benchies.

[Jan] found that the biggest speed bottleneck was in cooling a layer quickly enough that it would solidify before the printer laid down the next layer. He was able to get his layer speed down to about 0.6-0.4 seconds per layer, but had trouble going beyond that. He was able to improve the quality of his prints, however, by varying the nozzle temperature throughout the print. For this he used [Salim BELAYEL]’s postprocessing script, which increases hotend temperature when volumetric flow rate is high, and decreases it when flow rate is low. This keeps the plastic coming out of the nozzle at an approximately constant temperature. With this, [Jan] could print quite good sub-four and sub-thee minute Benchies, with almost no print degradation from the five-minute version. [Jan] predicts that this will become a standard feature of slicers, and we have to agree that this could help even less speed-obsessed printers.

Now onto less generally-applicable optimizations: [Jan] still needed stronger cooling to get faster prints, so he designed a circular duct that directed a plane of compressed air horizontally toward the nozzle, in the manner of an air knife. This wasn’t quite enough, so he precooled his compressed air with dry ice. This made it both colder and denser, both of which made it a better coolant. The thermal gradient this produced in the print bed seemed to cause it to warp, making bed adhesion inconsistent. However, it did increase build quality, and [Jan]’s confident that he’s made the best two-minute Benchy yet.

If you’re curious about Minuteman’s motion system, we’ve previously looked at how that was built. Of course, it’s also possible to speed up prints by simply adding more extruders.

X-ray crystallography, like mass spectroscopy and nuclear spectroscopy, is an extremely useful material characterization technique that is unfortunately hard for amateurs to perform. The physical operation isn’t too complicated, however, and as [Farben-X] shows, it’s entirely possible to build an X-ray diffractometer if you’re willing to deal with high voltages, ancient X-ray tubes, and soft X-rays.

[Farben-X] based his diffractometer around an old Soviet BSV-29 structural analysis X-ray tube, which emits X-rays through four beryllium windows. Two ZVS drivers power the tube: one to drive the electron gun’s filament, and one to feed a flyback transformer and Cockroft-Walton voltage multiplier which generate a potential across the tube. The most important part of the imaging system is the X-ray collimator, which [Farben-X] made out of a lead disk with a copper tube mounted in it. A 3D printer nozzle screws into each end of the tube, creating a very narrow path for X-rays, and thus a thin, mostly collimated beam.

To get good diffraction patterns from a crystal, it needed to be a single crystal, and to actually let the X-ray beam pass through, it needed to be a thin crystal. For this, [Farben-X] selected a sodium chloride crystal, a menthol crystal, and a thin sheet of mica. To grow large salt crystals, he used solvent vapor diffusion, which slowly dissolves a suitable solvent vapor in a salt solution, which decreases the salt’s solubility, leading to very slow, fine crystal growth. Afterwards, he redissolved portions of the resulting crystal to make it thinner.

For the actual experiment, [Farben-X] passed the X-ray beam through the crystals, then recorded the diffraction patterns formed on a slide of X-ray sensitive film. This created a pattern of dots around the central beam, indicating diffracted beams. The mathematics for reverse-engineering the crystal structure from this is rather complicated, and [Farben-X] hadn’t gotten to it yet, but it should be possible.

We would recommend a great deal of caution to anyone considering replicating this – a few clips of X-rays inducing flashes in the camera sensor made us particularly concerned – but we do have to admire any hack that coaxed such impressive results out of such a rudimentary setup. If you’re interested in further reading, we’ve covered the basics of X-ray crystallography before. We’ve also seen a few X-ray machines.

Although not nearly as intimidating as her ceiling-mounted hanging arm body, GLaDOS spent a significant portion of the Portal 2 game in a stripped-down computer powered by a potato battery. [Dave] had already made a version of her original body, but it was built around a robotic arm that was too expensive for the project to be really accessible. For his latest project, therefore, he’s created a AI-powered version of GLaDOS’s potato-based incarnation, which also serves as a fun introduction to building AI systems.

[Dave] wanted the system to work offline, so he needed a computer powerful enough to run all of his software locally. He chose an Nvidia Jetson Orin Nano, which was powerful enough to run a workable software system, albeit slowly and with some memory limitations. A potato cell unfortunately doesn’t generate enough power to run a Jetson, and it would be difficult to find a potato large enough to fit the Jetson inside. Instead, [Dave] 3D-printed and painted a potato-shaped enclosure for the Jetson, a microphone, a speaker, and some supplemental electronics.

A large language model handles interactions with the user, but most models were too large to fit on the Jetson. [Dave] eventually selected Llama 3.2, and used LlamaIndex to preprocess information from the Portal wiki for retrieval-augmented generation. The model’s prompt was a bit difficult, but after contacting a prompt engineer, [Dave] managed to get it to respond to the hapless user in an appropriately acerbic manner. For speech generation, [Dave] used Piper after training it on audio files from the Portal wiki, and for speech recognition used Vosk (a good programming exercise, Vosk being, in his words, “somewhat documented”). He’s made all of the final code available on GitHub under the fitting name of PotatOS.

The end result is a handheld device that sarcastically insults anyone seeking its guidance. At least Dave had the good sense not to give this pernicious potato control over his home.

Modern fertilizer manufacturing uses the Haber-Bosch and Ostwald processes to fix aerial nitrogen as ammonia, then oxidize the ammonia to nitric acid. Having already created a Haber-Bosch reactor for ammonia production, [Markus Bindhammer] took the obvious next step and created an Ostwald reactor to make nitric acid.

[Markus]’s first step was to build a sturdy frame for his apparatus, since most inexpensive lab stands are light and tip over easily – not a good trait in the best of times, but particularly undesirable when working with nitrogen dioxide and nitric acid. Instead, [Markus] built a frame out of aluminium extrusion, T-nuts, threaded rods, pipe clamps, and a few cut pieces of aluminium.

Once the frame was built, [Markus] mounted a section of quartz glass tubing above a gas burner intended for camping, and connected the output of the quartz tube to a gas washing bottle. The high-temperature resistant quartz tube held a mixture of alumina and platinum wool (as we’ve seen him use before), which acted as a catalyst for the oxidation of ammonia. The input to the tube was connected to a container of ammonia solution, and the output of the gas washing bottle fed into a solution of universal pH indicator. A vacuum ejector pulled a mixture of air and ammonia vapors through the whole system, and a copper wool flashback arrestor kept that mixture from having explosive side reactions.

After [Markus] started up the ejector and lit the burner, it still took a few hours of experimentation to get the conditions right. The issue seems to be that even with catalysis, ammonia won’t oxidize to nitrogen oxides at too low a temperature, and nitrogen oxides break down to nitrogen and oxygen at too high a temperature. Eventually, though, he managed to get the flow rate right and was rewarded with the tell-tale brown fumes of nitrogen dioxide in the gas washing bottle. The universal indicator also turned red, further confirming that he had made nitric acid.

Thanks to the platinum catalyst, this reactor does have the advantage of not relying on high voltages to make nitric acid. Of course, you’ll still need get ammonia somehow.

For those of us who aren’t blessed with a green thumb and who are perhaps a bit forgetful, plants can be surprisingly difficult to keep alive. In those cases, some kind of automation, such as [Justin Buchanan]’s Oasis smart terrarium, is a good way to keep our plants from suffering too much.

The Oasis has an ultrasonic mister to water the plants from a built-in tank, LED grow lights, fans to control airflow, and a temperature and humidity sensor. It connects to the local WiFi network and can set up recurring watering and lighting schedules based on network time. Most of the terrarium is 3D-printed, with a section of acrylic tubing providing the clear walls. Before installing the electronics, it’s a good idea to waterproof the printed parts with low-viscosity epoxy, particularly since the water tank is located at the top of the terrarium, where a leak would drip directly onto the control electronics.

An ESP32-C3 controls the terrarium; it uses a MOSFET circuit to drive the ultrasonic mister, an SHT30 sensor to measure humidity and temperature, and a PWM driver circuit to control the LEDs. Conveniently, [Justin] also wrote a piece of command-line client software that can find online terrariums on the local network, configure WiFi, set the terrarium’s schedule, control its hardware, and retrieve data from its sensors. Besides this, Oasis also exposes a web interface that performs the same functions as the command-line client.

This isn’t the first automated terrarium we’ve seen, though it is the most aesthetically refined. They aren’t just for plants, either; we’ve seen a system to keep geckos comfortable.

[Ruud], the creator of [Capturing Dust], started his latest video with what most of us would consider a solved problem: the dust collection system for his shop already had a three-stage centrifugal dust separator with more than 99.7% efficiency. This wasn’t quite as efficient as it could be, though, so [Ruud]’s latest upgrade shrinks the size of the third stage while increasing efficiency to within a rounding error of 99.9%.

The old separation system had two stages to remove large and medium particles, and a third stage to remove fine particles. The last stage was made out of 100 mm acrylic tubing and 3D-printed parts, but [Ruud] planned to try replacing it with two parallel centrifugal separators made out of 70 mm tubing. Before he could do that, however, he redesigned the filter module to make it easier to weigh, allowing him to determine how much sawdust made it through the extractors. He also attached a U-tube manometer (a somewhat confusing name to hear on YouTube) to measure pressure loss across the extractor.

The new third stage used impellers to induce rotational airflow, then directed it against the circular walls around an air outlet. The first design used a low-profile collection bin, but this wasn’t keeping the dust out of the air stream well enough, so [Ruud] switched to using plastic jars. Initially, this didn’t perform as well as the old system, but a few airflow adjustments brought the efficiency up to 99.879%. In [Ruud]’s case, this meant that of 1.3 kilograms of fine sawdust, only 1.5 grams of dust made it through the separator to the filter, which is certainly impressive in our opinion. The design for this upgraded separator is available on GitHub.

[Ruud] based his design off of another 3D-printed dust separator, but adapted it to European fittings. Of course, the dust extractor is only one part of the problem; you’ll still need a dust routing system.

Thanks to [Keith Olson] for the tip!

As far as giving mechanical instruments electronic control goes, drums are probably the best candidate for conversion; learning to play them is challenging and loud for a human, but they’re a straightforward matter for a microcontroller. [Jeremy Cook]’s latest project takes this approach by using an Arduino Opta to play a tongue drum.

[Jeremy]’s design far the drum controller was inspired by the ring-shaped arrangement of the Cray 2 supercomputer. A laser-cut MDF frame forms a C-shape around the tongue drum, and holds eight camera mount friction arms. Each friction arm holds a solenoid above a different point on the drum head, making it easy to position them. A few supports were 3D-printed, and some sections of PVC tubing form pivots to close the ring frame. [Jeremy] found that the the bare metal tips of the solenoids made a harsh sound against the drum, so he covered the tips of six solenoids with plastic caps, while the other two uncoated tips provide an auditory contrast.

The Arduino Opta is an open-source programmable logic controller normally intended for industrial automation. Here, its silent solid-state relays drive the solenoids, as [Jeremy]’s done before in an earlier experiment. The Opta is programmed to accept MIDI input, which [Jeremy] provided from two of the MIDI controllers which we’ve seen him build previously. He was able to get it working in time for the 2024 Orlando Maker Faire, which was the major time constraint.

Of course, for a project like this you need a MIDI controller, and we’ve previously seen [Jeremy] convert a kalimba into such a controller. We’ve seen this kind of drum machine at least once before, but it’s more common to see a purely electronic implementation.

If you’ve put in all the necessary practice to learn bike tricks, you’d probably like an appropriately dramatic soundtrack to accompany your stunts. A team of students working on a capstone project at the University of Washington took this natural desire a step further with the Music Bike, a system that generates adaptive music in response to the bike’s motion.

The Music Bike has a set of sensors controlled by an ESP32-S3 mounted beneath the bike seat. The ESP32 transmits the data it collects over BLE to an Android app, which in turn uses the FMOD Studio adaptive sound engine to generate the music played. An MPU9250 IMU collects most position and motion data, supplemented by a hall effect sensor which tracks wheel speed and direction of rotation.

When the Android app receives sensor data, it performs some processing to detect the bike’s actions, then uses these to control FMOD’s output. The students tried using machine learning to detect bike tricks, but had trouble with latency and accuracy, so they switched to a threshold classifier. They were eventually able to detect jumps, 180-degree spins, forward and reverse motion, and wheelies. FMOD uses this information to modify music pitch, alter instrument layering, and change the track. The students gave an impressive in-class demonstration of the system in the video below (the demonstration begins at 4:30).

Surprisingly enough, this isn’t the first music-producing bike we’ve featured here. We’ve also seen a music-reactive bike lighting system.

Thanks to [Blake Hannaford] for the tip!

For quite some time now, Marlin has been the firmware of choice for any kind of custom 3D printer, with only Klipper offering some serious competition in the open-source world. [Liam Powell] aims to introduce some more variety with the development of Prunt, a 3D printer control board and firmware stack.

Smooth motion control is Prunt’s biggest advantage: Klipper and Marlin use trapezoidal (three-phase) motion profiles, which aim for acceleration changes with physically impossible rapidity, leading to vibrations and ringing on prints. By contrast, Prunt uses a more physically realistic 31-phase motion profile. This lets the user independently adjust velocity, acceleration, jerk, snap, and crackle (the increasingly higher-order derivatives of position with respect to time) to reduce vibration and create smoother prints. To avoid sharp accelerations, Prunt can also turn corners into 15-degree Bézier curves.

The focus on smooth motion isn’t just a software feature; the Prunt control board uses hardware timers to control step generation, rather than the CPU. This avoids the timing issues which Klipper sometimes faces, and avoids slowing other parts of the program down. The board also seems to have a particular focus on avoiding electrical damage. It can detect short circuits in the heaters, thermistors, fans, and endstops, and can cut power and give the user a warning when one occurs. If the board somehow experiences a serious electrical fault, the USB port is isolated to prevent damage to the host computer. The firmware’s source is available on GitHub.

If you’re more interested in well-established programs, we’ve given a quick introduction to Klipper in the past. We’ve also seen people develop their own firmware for the Bambu Lab X1.

During Apple’s late-90s struggles with profitability, it made a few overtures toward licensing its software to other computer manufacturers, while at the same time trying to modernize its operating system, which was threatening to slip behind Windows. While Apple eventually scrapped their licensing plans, an interesting product of the situation was Rhapsody OS. Although Apple was still building PowerPC computers, Rhapsody also had compatibility with Intel processors, which [Omores] put to good use by running it on a relatively modern i7-3770 CPU.

[Omores] selected a Gigabyte GA-Z68A-D3-B3 motherboard because it supports IDE emulation for SATA drives, a protocol which Rhapsody requires. The operating system installer needs to run from two floppy disks, one for boot and one for drivers. The Gigabyte motherboard doesn’t support a floppy disk drive, so [Omores] used an older Asus P5E motherboard with a floppy drive to install Rhapsody onto an SSD, then transferred the SSD to the Gigabyte board. The installation initially had a kernel panic during installation caused by finding too much memory available. Limiting the physical RAM available to the OS by setting the maxmem value solved this issue.

After this, the graphical installation went fairly smoothly. A serial mouse was essential here, since Rhapsody doesn’t support USB. It detected the video card immediately, and eventually worked with one of [Omores]’s ethernet cards. [Omores] also took a brief look at Rhapsody’s interface. By default, there were no graphical programs for web browsing, decompressing files, or installing programs, so some command line work was necessary to install applications. Of course, the highlight of the video was the installation of a Doom port (RhapsoDoom).

This isn’t the first obscure Apple operating system we’ve seen; some of them have even involved updates to Apple’s original releases. We’ve also seen people build Apple hardware.

Thanks to [Stephen Walters] for the tip!

Most people know that they shouldn’t plug strange flash drives into their computers, but what about a USB cable? A cable doesn’t immediately register as an active electronic device to most people, but it’s entirely possible to hide a small, malicious microcontroller inside the shell of one of the plugs. [Joel Serna Moreno] and some collaborators have done just that with their Evil Crow Cable-Wind.

This cable comes in two variants: one USB-A to USB-C, and one with USB-C to USB-C. A tiny circuit board containing an ESP32-S3 hides inside a USB-C plug on each cable, and can carry out a keystroke injection attack. The cable’s firmware is open-source, and has an impressive set of features: a payload syntax checker, payload autocompletion, OS detection, and the ability to impersonate the USB device of your choice.

The cable provides a control interface over WiFi, and it’s possible to edit and deploy live payloads without physical access to the cable (this is where the syntax checker should be particularly useful). The firmware also provides a remote shell for computers without a network connection; the cable opens a shell on the target computer which routes commands and responses through the cable’s WiFi connection (demonstrated in the video below).

The main advantage of the Evil Crow Cable Wind is its price: only about $25, at which point you can afford to lose a few during deployment. We’ve previously seen a malicious cable once before. Of course, these attacks aren’t limited to cables and USB drives; we’ve seen them in USB-C docks, in a gaming mouse, and the fear of them in fans.

Thanks to [rustysun9] for the tip!

Both small children and cats have a certain tendency to make loud noises at inopportune times, but what if there were a way to combine these auditory effects? This seems to have been the reasoning behind the creation of the Meowsic keyboard, a children’s keyboard that renders notes as cats’ meows. [Steve Gilissen], an appreciator of unusual electronic instruments, discovered that while there had been projects that turned the Meowsic keyboard into a MIDI output device, no one had yet added MIDI input to it, which of course spurred the creation of his Meowsic MIDI adapter.

The switches in the keys of the original keyboard form a matrix of rows and columns, so that creating a connection between a particular row and column plays a certain note. [Steve]’s plan was to have a microcontroller read MIDI input, then connect the appropriate row and column to play the desired note. The first step was to use a small length of wire to connect rows and columns, thus manually mapping connections to notes. After this tedious step, he designed a PCB that hosts an Arduino Nano to accept input, two MCP23017 GPIO expanders to give it enough outputs, and CD4066BE CMOS switches to trigger the connections.

[Steve] was farsighted enough to expect some mistakes in the PCB, so he checked the connections before powering the board. This revealed a few problems, which some bodge wires corrected. It still didn’t play during testing, and after a long debugging session, he realized that two pins on an optoisolator were reversed. After fixing this, it finally worked, and he was able to create the following video.

Most of the MIDI hacks we’ve seen involved creating MIDI outputs, including one based on a Sega Genesis. We have seen MIDI input added to a Game Boy, though.

Most of us spend our lives within reach of a device that provides a clock, stopwatch, and a timer – you’re almost certainly reading this article on such a device – but there are fewer options if you want a screen-free clock. [Michael Suguitan]’s TOKIDOKI rectifies this situation by combining those three functions into a single, physical, analog clock face.

More after the break…

TOKIDOKI displays time by lighting the appropriate segments of two concentric rings of colored LEDs (Adafruit Neopixel rings); the inner ring indicates hours, while the outer ring displays minutes. There is one clock hand, and while it does indicate the passage of time in some situations, its main function is as a dial to control the clock’s different functions. The hand is connected to a Dynamixel XL-330 servo motor, which also serves as a position sensor. Winding the dial clockwise starts a countdown timer, with each successive full rotation switching to a larger unit of time (a fun/unsettling feature is that the largest chronometric unit is the user’s expected lifetime: 84 years). Winding counterclockwise either starts a stopwatch or sets an alarm, depending on how many full rotations you make.

A Raspberry Pi Pico running some MicroPython firmware manages the device and gets the current time from a local network. To soften the light’s quality, the LED rings are pointed backwards to provide back-lighting off of a recessed surface. The entire device is powered by USB-C, and is enclosed in a 3D-printed housing.

This project was designed as an experiment in minimal interfaces, and it certainly achieved that goal, though we imagine that it takes a bit of time to get used to using this clock. We always enjoy seeing innovative clocks here, from digital to analogue, and those that split the difference.

Despite the repeated warnings of system administrators, IT personnel, and anyone moderately aware of operational security, there are still quite a few people who will gladly plug a mysterious flash drive into their computers to see what’s on it. Devices which take advantage of this well-known behavioral vulnerability have a long history, the most famous of which is Hak5’s USB Rubber Ducky. That emulates a USB input device to rapidly execute attacker-defined commands on the target computer.

The main disadvantage of these keystroke injection attacks, from the attacker’s point of view, is that they’re not particularly subtle. It’s usually fairly obvious when something starts typing thousands of words per minute on your computer, and the victim’s next move is probably a call to IT. This is where [Krzysztof Witek]’s open-source Rubber Ducky clone has an advantage: it uses a signal detected by a SYN480R1 RF receiver to trigger the deployment of its payload. This does require the penetration tester who uses this to be on the site of the attack, but unlike with an always-on or timer-delayed Rubber Ducky, the attacker can trigger the payload when the victim is distracted or away from the computer.

This project is based around the ATmega16U2, and runs a firmware based on microdevt, a C framework for embedded development which [Krzysztof] also wrote. The project includes a custom compiler for a reduced form of Hak5’s payload programming language, so at least some of the available DuckyScript programs should be compatible with this. All of the project’s files are available on GitHub.

Perhaps due to the simplicity of the underlying concept, we’ve seen a few open source implementations of malicious input devices. One was even built into a USB cable.

It’s a problem that few of us will ever face, but if you ever have to calibrate your scanning electron microscope, you’ll need a resolution target with a high contrast under an electron beam. This requires an extremely small pattern of alternating high and low-density materials, which [ProjectsInFlight] created in his latest video by depositing gold nanoparticles on a silicon slide.

[ProjectsInFlight]’s scanning electron microscope came from a lab that discarded it as nonfunctional, and as we’ve seen before, he’s since been getting it back into working condition. When it was new, it could magnify 200,000 times and resolve features of 5.5 nm, and a resolution target with a range of feature sizes would indicate how high a magnification the microscope could still reach. [ProjectsInFlight] could also use the target to make before-and-after comparisons for his repairs, and to properly adjust the electron beam.

Since it’s easy to get very flat silicon wafers, [ProjectsInFlight] settled on these as the low-density portion of the target, and deposited a range of sizes of gold nanoparticles onto them as the high-density portion. To make the nanoparticles, he started by dissolving a small sample of gold in aqua regia to make chloroauric acid, then reduced this back to gold nanoparticles using sodium citrate. This gave particles in the 50-100 nanometer range, but [ProjectsInFlight] also needed some larger particles. This proved troublesome for a while, until he learned that he needed to cool the reaction temperature solution to near freezing before making the nanoparticles.

Using these particles, [ProjectsInFlight] was able to tune the astigmatism settings on the microscope’s electron beam so that it could clearly resolve the larger particles, and just barely see the smaller particles – quite an achievement considering that they’re under 100 nanometers across!

Electron microscopes are still a pretty rare build, but not unheard-of. If you ever find one that’s broken, it could be a worthwhile investment.