This property has been used to 3D print objects by using a syringe tip as if it were a nozzle in a filament-based printer. As long as the liquid is being printed into contact with a salt solution, the result is a polymer that solidifies upon leaving the syringe.
What’s also interesting is that the process by which the PNIPAM-based solutions solidify is entirely reversible. Researchers demonstrate printing, breaking down, then re-printing, which is an awfully neat trick. Finally, by mixing different additives in with PNIPAM, one can obtain different properties in the final product. For example, researchers demonstrate making conductive prints by adding carbon nanotubes.
While we’ve seen the concept of printing with liquids by extruding them into a gel bath or similar approach, we haven’t seen a process that prides itself on being so reversible before. The research paper with all the details is available here, so check it out for all the details.
We love close-up pictures of intricate work, and [w] hits the spot with a tiny joule thief in a fuse case (social media post, embedded below) powered by an old coin cell from a watch. It’s so tiny!
Ethernet transformers contain tiny coils.
A joule thief is a sort of minimum-component voltage booster that can suck nearly every last drop of energy from even seemingly-drained batteries, and is probably most famously used to light LEDs from cells that are considered “dead”.
Many joule thief designs feature hand-wound coils, which is great for junk box builds but certainly becomes more of a challenge for a tiny build like this one.
We really like that [w] salvaged a miniscule coil from an Ethernet transformer, most of which look like blocky SMD components from the outside but actually contain tiny coils.
The joule thief has been the basis of plenty of hacks over the years, and it’s always nice to see new twists on the concept.
Miniature 'Joule thief' in a fuse case powered by a 10 year old watch battery pic.twitter.com/flJHggDRc8
Data manipulation is at the heart of computation, and a system is said to be Turing-complete if it can be configured to manipulate data in a way that makes implementing arbitrary computation possible. [Keigo Oka] shared a proof that find and mkdir together are Turing-complete, which is to say, a system with only GNU’s find and mkdir has access to enough functionality to satisfy the requirements of Turing completeness, which ignores questions of efficiency or speed.
[Keigo Oka]’s first attempt at a proof worked to implement Rule 110, an elementary cellular automata configuration that has been shown to be Turing-complete, or ‘universal’, but has been updated to implement a tag system as it’s proof, and you can see it in action for yourself.
A safe haven to preserve samples of biodiversity from climate change, habitat loss, natural disaster, and other threats is recognized as a worthwhile endeavor. Everyone knows good backup practice involves a copy of critical elements at a remote location, leading some to ask: why not the moon?
A biological sample repository already exists in the form of the Svalbard global seed vault, located in a mountain on a remote island in the Arctic circle. Even so, not even Svalbard is out of the reach of our changing Earth. In 2017, soaring temperatures in the Arctic melted permafrost in a way no one imagined would be possible, and water infiltrated the facility. Fortunately the flooding was handled by personnel and no damage was done to the vault’s contents, but it was a wake-up call.
An off-site backup that requires no staffing could provide some much-needed redundancy. Deep craters near the moon’s polar regions offer stable and ultra-cold locations that are never exposed to sunlight, and could offer staffing-free repositories if done right. The lunar biorepository proposal has the details, and is thought-provoking, at least.
The moon’s lack of an atmosphere is inconvenient for life, but otherwise pretty attractive for some applications. A backup seed vault is one, and putting a giant telescope in a lunar crater is another.
Ever heard of Apollo Computer, Inc.? They were one of the first graphical workstation vendors in the 1980s, and at the time were competitors to Sun Microsystems.
But that’s enough dry historical context. Feast your eyes on this full-color, 26-page product brochure straight from 1988 for the Series 10000 “Personal Supercomputer” featuring multiple processors and more! It’s loaded with information about their hardware and design architecture, giving a unique glimpse into just how Apollo was positioning their offerings, and the markets they were targeting with their products.
Apollo produced their own hardware and software, which meant much of it was proprietary. Whatever happened to Apollo? They were acquired by Hewlett-Packard in 1989 and eventually shuttered over the following decade or so. Find yourself intrigued? [Jim Rees] of The Apollo Archive should be your next stop for everything Apollo-oriented.
Vintage computing has a real charm of its own, but no hardware lasts forever. Who knows? Perhaps we might someday see an Apollo workstation brought to life in VR, like we have with the Commodore 64 or the BBC Micro (which even went so far as to sample the sound of authentic keystrokes. Now that’s dedication.)
Here’s a short research paper from 2013 that explains how to create “hydroglyphics”, or writing with selecting surface wetting. In it, an apparently normal-looking petri dish is treated so as to reveal a message when wetted with water vapor. The contrast between hydrophobic and hydrophilic surfaces, which is not visible to the naked eye, becomes visible when misted with water. All it took was a mask, and a little treatment with a modified Tesla coil.
Plastics tend to be hydrophobic, meaning their surface repels water. These plastics also tend to be non-receptive to things like inks and adhesives. However, there is an industrial process called corona treatment (invented by Verner Eisby in 1951) that changes the surface energy of materials like plastics, rendering them more receptive to inks, coatings, and adhesives. Eisby’s company Vetaphone still exists today, and has a page describing the process.
What’s this got to do with the petri dishes and their secret messages? The process is essentially the same. By using a Tesla coil modified with a metal wire mesh, the surface of the petri dish is exposed to the coil’s discharge, altering its surface energy and rendering it hydrophilic. By selectively blocking the discharge with a nonconductive mask made from a foam sticker, the masked area remains hydrophobic. Mist the surface with water, and the design becomes visible.
The effects of corona treatment decay over time, but we think this is exactly the sort of thing that is worth keeping in mind just in case it ever comes in useful. Compact Tesla coils are fairly easy to get a hold of nowadays, but it’s also possible to make your own.
[Johannes] uses Stable Diffusion‘s SDXL Turbo to create a baseline image of “photo of a red brick house, blue sky”. The hardware dials act as manual controls for applying different embeddings to this baseline, such as “coral”, “moss”, “fire”, “ice”, “sand”, “rusty steel” and “cookie”.
By adjusting the dials, those embeddings are applied to the base image in varying strengths. The results are generated on the fly and are pretty neat to see, especially since there is no appreciable amount of processing time required.
The MIDI controller is integrated with the help of lunar_tools, a software toolkit on GitHub to facilitate creating interactive exhibits. As for the image end of things, we’ve previously covered how AI image generators work.
[Jeff Sandberg] has put a fair bit of effort into adding solar and battery storage with associated smarts to his home, but his energy usage statistics were incomplete. His solution was to read data from the utility meter using RTL-SDR to fill in the blanks. The results are good so far, and there’s no reason similar readings for gas and water can’t also be done.
[Jeff] uses the open source home automation software Home Assistant which integrates nicely with his solar and battery backup system, but due to the way his house is wired, it’s only aware of about half of the energy usage in the house. For example, [Jeff]’s heavy appliances get their power directly from the power company and are not part of the solar and battery systems. This means that Home Assistant’s energy statistics are incomplete.
Fortunately, in the USA most smart meters broadcast their data in a manner that an economical software-defined radio like RTL-SDR can access. That provided [Jeff] with the data he needed to get a much more complete picture of his energy usage.
While getting data from utility meters is conceptually straightforward, actually implementing things in a way that integrated with his system took a bit more work. If you’re finding yourself in the same boat, be sure to look at [Jeff]’s documentation to get some ideas.
[Ahron Wayne] succeeded in something he’s been trying to accomplish for some time: figuring out what’s inside a sealed Pokémon card packet without opening it. There’s a catch, however. It took buying an X-ray CT scanner off eBay, refurbishing and calibrating it, then putting a load of work into testing and scanning techniques. Then finally combining the data with machine learning in order to make useful decisions. It’s a load of work but [Ahron] succeeded by developing some genuinely novel techniques.
While using an X-ray machine to peek inside a sealed package seems conceptually straightforward, there are in fact all kinds of challenges in actually pulling it off. There’s loads of noise. So much that the resulting images give a human eyeball very little to work with. Luckily, there are also some things that make the job a little easier.
For example, it’s not actually necessary to image an entire card in order to positively identify it. Teasing out the individual features such as a fist, a tentacle, or a symbol are all useful to eliminate possibilities. Interestingly, as a side effect the system can easily spot counterfeit cards; the scans show up completely different.
When we first covered [Ahron]’s fascinating journey of bringing CT scanners back to life, he was able to scan cards but made it clear he wasn’t able to scan sealed packages. We’re delighted that he ultimately succeeded, and also documented the process. Check it out in the video below.
It would be better if humans didn’t toss cigarette butts on the ground in the first place, but change always takes longer than we think it should. In the meantime, researchers at the Italian Institute of Technology have used the problem as an opportunity to explore what seems to be a novel approach: attaching vacuum pickups to a robot’s feet, therefore removing the need for separate effectors.
VERO (Vacuum-cleaner Equipped RObot) is a robotic dog with a vacuum cleaner “backpack” and four hoses, one going down each leg. A vision system detects a cigarette butt, then ensures the robot plants a foot next to it, sucking it up. The research paper has more details, but the video embedded below gives an excellent overview.
While VERO needs to think carefully about route planning, using the legs as effectors is very efficient. Being a legged robot, VERO can navigate all kinds of real-world environments — including stairs — which is important because cigarette butts know no bounds.
Also, using the legs as effectors means there is no need for the robot to stop and wait while a separate device (like an arm with a vacuum pickup) picks up the trash. By simply planting a foot next to a detected cigarette butt, VERO combines locomotion with pickup.
It’s fascinating to see how the Mini Cheetah design has really become mainstream to the point that these robots are available off-the-shelf, and it’s even cooler to see them put to use. After all, robots tackling trash is a good way to leverage machines that can focus on specific jobs, even if they aren’t super fast at it.
An EDF (electric duct fan) is a motor that basically functions as a jet engine for RC aircraft. They’re built for speed, but to improve maneuverability (and because it’s super cool) [johnbecker31] designed a 3D-printable method of adjusting the EDF’s thrust on demand.
Before 3D printers were common, making something like this would have been much more work.
The folks at Flite Test released a video in which they built [john]’s design into a squat tester jet that adjusts thrust in sync with the aircraft’s control surfaces, as you can see in the header image above. Speaking of control surfaces, you may notice that test aircraft lacks a rudder. That function is taken over by changing the EDF’s thrust, although it still has ailerons that move in sync with the thrust system.
EDF-powered aircraft weren’t really feasible in the RC scene until modern brushless electric motors combined with the power density of lithium-ion cells changed all that. And with electronics driving so much, and technology like 3D printers making one-off hardware accessible to all, the RC scene continues to be fertile ground for all sorts of fascinating experimentation. Whether it’s slapping an afterburner on an EDF or putting an actual micro jet engine on an RC car.
Some time ago [Kelton] was working on a clock inspired by Rube Goldberg contraptions. It uses only a single motor, and he’s proud to now show off the finished product (video, embedded below.)
The clock shows hours on the left, and minutes on the right. Every sixty minutes the clock drops a marble. That marble kicks off a series of visually-satisfying operations that culminate in advancing the hour. Then everything resets, and it continues for as long as it has power.
The hour oscillates in a very satisfying manner as it locks in.
At the top of each hour, the minute hand tips a marble with a gravity cam. That marble runs down a track gaining enough momentum to flip a kicker, and a short series of falling dominoes builds enough force to tip and trigger the spring-loaded ratchet that locks in a new hour. You can skip directly to 2:09 if you just want to listen to [Kelton] explain the whole operation from beginning to end.
We think it’s very interesting to note that this clock’s complexity is, if anything, understated. Each of the mechanisms involved must individually reset by their own separate mechanisms, each of which are as intriguing as their showier counterparts, and we’re sure they were every bit as difficult to get just right. And of course, it’s all driven by a single motor.
You may recall the promising start this clock project was off to and we’re delighted to see it come to completion, especially considering its complexity. Not every project sees completion, and fewer still get a version two, but that’s okay. What really floats our boat is seeing the process and details as well as hearing about what worked and what didn’t. We’re glad this clock reached the finish line, but even if something doesn’t work out, there’s always something to learn.
Rare earth elements are used to produce magnets with very high strength that also strongly resist demagnetization, their performance is key to modern motors such as those in electric vehicles (EVs). The stronger the magnets, the lighter and more efficient a motor can be. So what exactly does it take to break up with rare earths?
Rare earth elements (REEs) are actually abundant in the Earth’s crust, technically speaking. The problem is they are found in very low concentrations, and inconveniently mixed with other elements when found. Huge amounts of ore are required to extract useful quantities, which requires substantial industrial processing. The processes involved are ecologically harmful and result in large amounts of toxic waste.
Moving away from rare earth magnets in EV motors would bring a lot of benefits, but poses challenges. There are two basic approaches: optimize a motor for non-rare-earth magnets (such as iron nitrides), or do away with permanent magnets entirely in favor of electromagnets (pictured above). There are significant engineering challenges to both approaches, and it’s difficult to say which will be best in the end. But research and prototypes are making it increasingly clear that effective REE-free motors are perfectly feasible. Breaking up with REEs and their toxic heritage would be much easier when their main benefit — technological performance — gets taken off the table as a unique advantage.
When homebrewing a CPU, one has to deal with microcode. Microcode is the low-level nuts and bolts of how, precisely, a CPU executes instructions (like opcodes) and performs functions such as updating the cycle counter or handling interrupt requests. To make this task easier, [Bob Alexander] created a microcode compiler built in Google Sheets to help with his own homebrew work, but it’s flexible and configurable enough to be useful to others, as well.
A CPU’s microcode usually lives in read-only memory, and writing the microcode is only one step in the journey. [Bob]’s tool compiles his microcode into files that can be burned into memory (multiple EEPROM chips, in [Bob]’s case) or used as a Verilog program in the case of implementing the CPU in an FPGA. It’s configurable enough to be adapted for other homebrew CPU projects, though one would of course have to re-write the microcode portion.
A read-only version of the spreadsheet makes for some fun browsing, and if it piques your interest enough to get a copy of your own complete with the compiler script, you can do that here. It uses Google Sheets, and writes the output files into one’s Google Drive.
This kind of low-level project really highlights the finer points of just how the hard work of digital computing gets done. A good example is the Gigatron which implemented a RISC CPU using only microcode, memory, and logic gates in the late 70s. We’ve even seen custom microcode used to aid complex debugging.
Useless robots (or useless machines) are devices that, when switched on, exist only to turn themselves back off. They are fun and fairly simple builds that are easy to personify, and really invite customization by their creators. Even so, [tobychui]’s Kawaii Useless Robot goes above and beyond in that regard. Not only will his creation dutifully turn itself off, but if the user persists in engaging it, Kawaii Useless Robot grows progressively (and adorably) upset which ultimately culminates in scooting about and trying to run away.
If anything, it gets cuter when upset.
This is actually a ground-up re-imagining of an original work [tobychui] saw from a Japanese maker twelve years ago. That original Kawaii Useless Robot did not have any design details, so [tobychui] decided to re-create his own.
Behind the laser-cut front panel is a dot matrix LED display made up of eight smaller units, and inside are a total of four motors, an ESP32 development board, and supporting electronics. A neat touch is the ability to allow connections over Wi-Fi for debugging or remote control. The project page has some nice photos of the interior that are worth checking out. It’s a very compact and efficient build!
Watch it in action in the video (embedded below) which also includes a tour of the internals and a thorough description of the functions.
Large Language Models (LLMs) can produce extremely human-like communication, but their inner workings are something of a mystery. Not a mystery in the sense that we don’t know how an LLM works, but a mystery in the sense that the exact process of turning a particular input into a particular output is something of a black box.
This “black box” trait is common to neural networks in general, and LLMs are very deep neural networks. It is not really possible to explain precisely why a specific input produces a particular output, and not something else.
Why? Because neural networks are neither databases, nor lookup tables. In a neural network, discrete activation of neurons cannot be meaningfully mapped to specific concepts or words. The connections are complex, numerous, and multidimensional to the point that trying to tease out their relationships in any straightforward way simply does not make sense.
Neural Networks are a Black Box
In a way, this shouldn’t be surprising. After all, the entire umbrella of “AI” is about using software to solve the sorts of problems humans are in general not good at figuring out how to write a program to solve. It’s maybe no wonder that the end product has some level of inscrutability.
This isn’t what most of us expect from software, but as humans we can relate to the black box aspect more than we might realize. Take, for example, the process of elegantly translating a phrase from one language to another.
I’d like to use as an example of this an idea from an article by Lance Fortnow in Quanta magazine about the ubiquity of computation in our world. Lance asks us to imagine a woman named Sophie who grew up speaking French and English and works as a translator. Sophie can easily take any English text and produce a sentence of equivalent meaning in French. Sophie’s brain follows some kind of process to perform this conversion, but Sophie likely doesn’t understand the entire process. She might not even think of it as a process at all. It’s something that just happens. Sophie, like most of us, is intimately familiar with black box functionality.
The difference is that while many of us (perhaps grudgingly) accept this aspect of our own existence, we are understandably dissatisfied with it as a feature of our software. New research has made progress towards changing this.
Identifying Conceptual Features in Language Models
We know perfectly well how LLMs work, but that doesn’t help us pick apart individual transactions. Opening the black box while it’s working yields only a mess of discrete neural activations that cannot be meaningfully mapped to particular concepts, words, or whatever else. Until now, that is.
Recent developments have made the black box much less opaque, thanks to tools that can map and visualize LLM internal states during computation. This creates a conceptual snapshot of what the LLM is — for lack of a better term — thinking in the process of putting together its response to a prompt.
Anthropic have recently shared details on their success in mapping the mind of their Claude 3.0 Sonnet model by finding a way to match patterns of neuron activations to concrete, human-understandable concepts called features.
A feature can be just about anything; a person, a place, an object, or more abstract things like the idea of upper case, or function calls. The existence of a feature being activated does not mean it factors directly into the output, but it does mean it played some role in the road the output took.
With a way to map groups of activations to features — a significant engineering challenge — one can meaningfully interpret the contents of the black box. It is also possible to measure a sort of relational “distance” between features, and therefore get an even better idea of what a given state of neural activation represents in conceptual terms.
Making Sense of it all
One way this can be used is to produce a heat map that highlights how heavily different features were involved in Claude’s responses. Artificially manipulating the weighting of different concepts changes Claude’s responses in predictable ways (video), demonstrating that the features are indeed reasonably accurate representations of the LLM’s internal state. More details on this process are available in the paper Scaling Monosemanticity: Extracting Interpretable Features from Claude 3 Sonnet.
Mapping the mind of a state-of-the-art LLM like Claude may be a nontrivial undertaking, but that doesn’t mean the process is entirely the domain of tech companies with loads of resources. Inspectus by [labml.ai] is a visualization tool that works similarly to provide insight into the behavior of LLMs during processing. There is a tutorial on using it with a GPT-2 model, but don’t let that turn you off. GPT-2 may be older, but it is still relevant.
Research like this offers new ways to understand (and potentially manipulate, or fine-tune) these powerful tools., making LLMs more transparent and more useful, especially in applications where lack of operational clarity is hard to accept.
[mircemk] shows how to create a simple non-contact proximity sensor using little more than an Arduino Nano board, and a convenient software library intended to measure the value of capacitors.
The prototype has a threshold set via potentiometer for convenience.
The basic idea is that it’s possible to measure a capacitor’s capacitance using two microcontroller pins and the right software, so by using a few materials to create an open-style capacitor, one can monitor it for changes and detect when anything approaches enough to alter its values past a given threshold, creating a proximity sensor.
The sensor shown here is essentially two plates mounted side-by-side, attached to an Arduino Nano using the Capacitor library which uses just two pins, one digital and one analog.
As configured, [mircemk]’s sensor measures roughly thirty picofarads, and that value decreases when approached by something with a dielectric constant that is different enough from the air surrounding the sensor. The sensor ignores wood and plastic, but an approaching hand is easily detected. The sensor also detects liquid water with similar ease, either in the form of pooled liquid, or filled bottles.
We’ve also seen a spring elegantly used as a hidden touch sensor that works through an enclosure’s wall by using similar principles, so the next time you need a proximity or touch-sensitive sensor in a project, reaching for the junk box might get you where you need to go. Watch [mircemk]’s sensor in action in the video, just below the page break.
Conectar
This property has been used to 3D print objects by using a syringe tip as if it were a nozzle in a filament-based printer. As long as the liquid is being printed into contact with a salt solution, the result is a polymer that solidifies upon leaving the syringe.
