Ore Formation: Return Of The Revenge Of The Fluids

October 21, 2025 by Tyler August 16 Comments

In the last edition of our ongoing series on how planets get ore– those wonderful rocks rich in industrial minerals worth mining– we started talking about hydrothermal fluid deposits. Hydrothermal fluid is the very hot, very salty, very corrosive water that sweats out of magma as it cools underground and under pressure.

We learned that if the fluid stays in the magma chamber and encourages the growth of large crystals there, we call that a pegmatite deposit. If it escapes following cracks in the surface rock, it creates the characteristic veins of an orogenic deposit. What if the fluid gets out of the magma chamber, but doesn’t find any cracks?

Perhaps the surrounding rock is slightly permeable to water, and the hydrothermal fluid can force its way through, eating away at the base rock and remineralizing it with new metals as it goes. That can happen! We call it a porphyry deposit, particularly in igneous rock. It’s not exactly surprising that a hydrothermal fluid would find igneous rock: the fluid is volcanic in origin, after all, just like igneous rock. (That’s the definition of igneous: a rock of volcanic origin.) Igneous rocks, like granite, tend not to be terribly reactive so the fluid can diffuse through relatively unchanged.

Igneous rocks aren’t the only option, though. If the hydrothermal fluid hits carbonates, well, I did mention it’s acidic, right? Acid and carbonates are not friends, so all sorts of chemistry happens, such that geologists give the resulting metamorphic formation a special name: skarn. Though similar in origin, skarns are often considered a different type of deposit, so we’ll talk about the simpler case, diffusion through non-reactive rocks, before getting back to the rocks that sound like an 80s fantasy villain. (Beware Lord Skarn!)

Continue reading “Ore Formation: Return Of The Revenge Of The Fluids” →

Budget Stream Deck Clone Is Ripe For Hacking

October 21, 2025 by Lewin Day 11 Comments

The original Stream Deck was a purpose-built device to make it easier to manage a live video stream on the fly. Since its release, many other similar products have hit the market. Among them is the Ulanzi D200 U-Studio, which is proving popular with hackers for good reason.

[Rodrigo Laneth] has been digging into the D200, and found out it’s running Linux 5.10.160 on a quad-core Rockchip RK3308HS chip. Notably, he determined the kernel appears to be from Android, but that Ulanzi removed the Android userspace and “slapped Buildroot on top,” in his own words. Interesting, if not that unusual. What is key, however, is that the device has a fully open adb root shell, as noted by [lucasteske], which inspired [Rodrigo]’s investigation. This pretty much allows full access to the device, so you can make it do whatever weird thing your heart desires.

As you might expect, people are already making the D200 do fun stuff. [lucasteske] got it running DOOM in short order. Meanwhile, [Rodrigo] has it playing out Bad Apple!! at 30 FPS, with code and a deeper explanation available on GitHub.

It’s rare these days that manufacturers leave root open on any commercial device. You normally need to pull a few tricks to get that kind of access.

Continue reading “Budget Stream Deck Clone Is Ripe For Hacking” →

Reverse Engineering STL Files With FreeCAD

October 21, 2025 by Al Williams 30 Comments

If you think about it, STL files are like PDF files. You usually create them using some other program, export them, and then expect them to print. But you rarely do serious editing on a PDF or an STL. But what if you don’t have anything but the STL? [The Savvy Engineer] has a method to help you if you need to reverse engineer an STL file in FreeCAD. Check it out in the video below.

The problem is, of course, that STLs are made up of numerous little triangles. The trick is to switch workbenches and create a shape from mesh. That gets you part of the way.

Once you have a shape, you can convert it to a solid. At that point, you can create a refined copy. This gives you a proper CAD file that you can export to a STEP file. From there, you can use it in FreeCAD or nearly any other CAD package you like to use.

Once you have a proper object, you can easily use it like any other solid body in your CAD program. This is one of those things you won’t need every day, but when you do need it, it’ll come in handy.

Want to up your FreeCAD game? We can help. There are other ways to hack up STL files. You can even import them into TinkerCAD to do simple things, but they still aren’t proper objects.

Continue reading “Reverse Engineering STL Files With FreeCAD” →

Putting A Teensy To Task As A Transputer Link

October 20, 2025 by Dave Rowntree 8 Comments

One downside of working with the old Inmos Transputer devices is the rarity and cost of the original silicon. Obviously, you can’t sidestep the acquisition of the processor—unless you emulate—but what about replacing the IMS C011/C012 link chip? You need this (expensive) part to interface the transputer to the programming host, but as [Erturk Kocalar] discovered, it’s perfectly possible to coax a Teensy to do that job for you just as well.

The unusual two-bit start sequence differentiates a data packet from an ACK. It’s simple to emulate if you use the LSB of a 9-bit word as a dummy start bit!

Transputers work by utilizing an array of bit serial interfaces to connect a network of devices, allowing for cooperative computation on tasks too large to fit on a single device. This protocol is, at its link level, a simple asynchronous bit serial affair, with 11-bit data messages, and a raw two-bit frame for the acknowledge. The C011 device at its heart is just a specialized UART—it takes 8-bit parallel data from the host, dealing with handshaking, and pushes it out to the first transputer in the chain at 5, 10 or 20 Mbps, but inverted and with two start bits and a single stop bit. In parallel, it performs the same task in the reverse direction.

[Erturk] realized that the Teensy UART has an inverted mode and, crucially, a 9-bit data mode. This allows the second start bit to be generated as bit 0 of the word, with the remaining eight bits forming the payload. Simple stuff. Additionally, the Teensy UART is capable of the maximum transputer bitrate of 20 Mbps, without breaking a sweat.

Continue reading “Putting A Teensy To Task As A Transputer Link” →

The Lambda Papers: When LISP Got Turned Into A Microprocessor

October 20, 2025 by Maya Posch 17 Comments

The physical layout of the SCHEME-78 LISP-based microprocessor by Steele and Sussman. (Source: ACM, Vol 23, Issue 11, 1980)

During the AI research boom of the 1970s, the LISP language – from LISt Processor – saw a major surge in use and development, including many dialects being developed. One of these dialects was Scheme, developed by [Guy L. Steele] and [Gerald Jay Sussman], who wrote a number of articles that were published by the Massachusetts Institute of Technology (MIT) AI Lab as part of the AI Memos. This subset, called the Lambda Papers, cover the ideas from both men about lambda calculus, its application with LISP and ultimately the 1980 paper on the design of a LISP-based microprocessor.

Scheme is notable here because it influenced the development of what would be standardized in 1994 as Common Lisp, which is what can be called ‘modern Lisp’. The idea of creating dedicated LISP machines was not a new one, driven by the processing requirements of AI systems. The mismatch between the S-expressions of LISP and the typical way that assembly uses the CPUs of the era led to the development of CPUs with dedicated hardware support for LISP.

The design described by [Steele] and [Sussman] in their 1980 paper, as featured in the Communications of the ACM, features an instruction set architecture (ISA) that matches the LISP language more closely. As described, it is effectively a hardware-based LISP interpreter, implemented in a VLSI chip, called the SCHEME-78. By moving as much as possible into hardware, obviously performance is much improved. This is somewhat like how today’s AI boom is based around dedicated vector processors that excel at inference, unlike generic CPUs.

During the 1980s LISP machines began to integrate more and more hardware features, with the Symbolics and LMI systems featuring heavily. Later these systems also began to be marketed towards non-AI uses like 3D modelling and computer graphics. As however funding for AI research dried up and commodity hardware began to outpace specialized processors, so too did these systems vanish.

Top image: Symbolics 3620 and LMI Lambda Lisp machines (Credit: Jason Riedy)

High Performance Motor Control With FOC From The Ground Up

October 20, 2025 by Maya Posch 23 Comments

Testing the FOC-based motor controller. (Credit: Excessive Overkill, YouTube)

Vector Control, also known as Field Oriented Control or FOC is an AC motor control scheme that enables fine-grained control over a connected motor, through the precise control of its phases. In a recent video [Excessive Overkill] goes through the basics and then the finer details of how FOC works, as well as how to implement it. These controllers generally uses a proportional integral (PI) loop, capable of measuring and integrating the position of the connected motor, thus allowing for precise adjustments of the applied vector.

If this controller looks familiar, it is because we featured it previously in the context of reviving old industrial robotic arms. Whether you are driving the big motors on an industrial robot, or a much smaller permanent magnet AC (PMAC) motor, FOV is very likely the control mechanism that you want to use for the best results. Of note is that most BLDC motors are actually also PMACs with ESC to provide a DC interface.

Continue reading “High Performance Motor Control With FOC From The Ground Up” →

Blinking An LED With A Single Transistor

October 20, 2025 by Lewin Day 30 Comments

Let’s say you want to blink an LED. You might grab an Arduino and run the Blink sketch, or you might lace up a few components to a 555. But you needn’t go so fancy! [The Design Graveyard] explains how this same effect can be achieved with a single transistor.

The circuit in question is rather odd at first blush. The BC547 NPN transistor is hooked up between an LED and a resistor leading to a 12V DC line, with a capacitor across the emitter and collector. Meanwhile, the base is connected to… nothing! It’s just free-floating in the universe of its own accord. You might expect this circuit to do nothing at all, but if you power it up, the LED will actually start to flash.

The mechanism at play is relatively simple. The capacitor charges to 12 volts via the resistor. At this point, the transistor, which is effectively just acting as a poor diode in this case, undergoes avalanche breakdown at about 8.5 to 9 volts, and starts conducting. This causes the capacitor to discharge via the LED, until the voltage gets low enough that the transistor stops conducting once again. Then, the capacitor begins to charge back up, and the cycle begins again.

It’s a weird way to flash an LED, and it’s not really the normal way to use a transistor—you’re very much running it out of spec. Regardless, it does work for a time! We’ve looked at similar circuits before too. Video after the break.

Continue reading “Blinking An LED With A Single Transistor” →