[Nicholas Carlini] found some extra time on his hands over the holiday, so he decide to do something with “entirely no purpose.” The result: 84,688 regular expressions that can play chess using a 2-ply minmax strategy. No kidding. We think we can do some heavy-duty regular expressions, but this is a whole other level.

As you might expect, the code to play is extremely simple as it just runs the board through series of regular expressions that implement the game logic. Of course, that doesn’t count the thousands of strings containing the regular expressions.

How does this work? Luckily, [Nicholas] explains it in some detail. The trick isn’t making a chess engine. Instead, he creates a “branch-free, conditional-execution, single-instruction multiple-data CPU.” Once you have a CPU, of course it is easy to play chess. Well, relatively easy, anyway.

The computer’s stack and registers are all in a long string, perfect for evaluation by a regular expression. From there, the rest is pretty easy. Sure, you can’t have loops and conditionals can’t branch. You can, however, fork a thread into two parts. Pretty amazing.

Programming the machine must be pretty hard, right? Well, no. There’s also a sort-of language that looks a lot like Python that can compile code for the CPU. For example:

def fib():
    a = 1
    b = 2
   for _ in range(10):
        next = a + b
        a = b
        b = next

Then you “only” have to write the chess engine. It isn’t fast, but that really isn’t the point.

Of course, chess doesn’t have to be that hard. The “assembler” reminds us a bit of our universal cross assembler.

We always enjoy videos from the [Mathologer], but we especially liked the recent video on the Helicone, a toy with a surprising connection to mathematics. The toy is cool all by itself, but the video shows how a sufficiently large heliocone models many “natural numbers” and acts, as [Mathologer] puts it, acts as “microscope to probe the nature of numbers.”

The chief number of interest is the so-called golden ratio. A virtual model of the toy allows easy experimentation and even some things that aren’t easily possible in the real world. The virtual helicone also allows you to make a crazy number of layers, which can show certain mathematical ideas that would be hard to do in a 3D print or a wooden toy.

Apparently, the helicone was [John Edmark’s] sculpture inspired by DNA spirals, so it is no surprise it closely models nature. You can 3D print a real one.

Of course, the constant π makes an appearance. Like fractals, you can dive into the math or just enjoy the pretty patterns. We won’t judge either way.

We’ve seen math sequences in clocks that remind us of [Piet Mondrian]. In fact, we’ve seen more than one of those.

We like mechanical calculators like slide rules, but we have to admit that we had not heard of the Ott Derivimeter that [Chris Staecker] shows us in a recent video. As the name implies, the derivimeter finds the derivative of a function. To do that, you have to plot the function on a piece of paper that the meter can measure.

If you forgot calculus or skipped it altogether, the derivative is the rate of change. If you plot, say, your car’s speed vs time, the parts where you accelerate or decelerate will have a larger derivative (either positive or negative, in the decelerate case). If you hold a steady speed, the derivative will be zero.

To use the derivimeter, you sight the curve through the center glass and twist the device so the cursor, which is a lens and mirror system that lets you precisely find a tangent line. You can read the angle and find the true derivative using a table of tangents.

[Chris] has another derivimeter from Gerber. However, he found a different type of derivimeter that uses a prism, and he sure would like to find one of those for his collection.

Calculus is actually useful and not as hard as people think if you get the right explanations. This isn’t exactly a slide rule, but since it is a mechanical math device, we think it counts anyway.

Normally, you have a choice with PCB prototypes: fast or cheap. [Stephen Hawes] has been trying fiber lasers to create PCBs. He’s learned a lot which he shares in the video below. Very good-looking singled-sided boards take just a few minutes. Fiber lasers are not cheap but they are within range for well-off hackers and certainly possible for a well-funded hackerspace.

One thing that’s important is to use FR1 phenolic substrate instead of the more common FR4. FR4 uses epoxy which will probably produce some toxic fumes under the laser.

We were surprised at how good the boards looked. Of course, the line definition was amazing, as you’d expect from a laser with details down to 200 microns (a little less than 0.008″), and he thinks it can go even lower. The laser also drills holes and can cut the board outline. A silk screen makes it easy to add a solder mask, and the laser will even cut the mask. [Stephen] also etched “silk screening” into the solder mask and filled it with a different color solder mask to make nice board legends.

Registration is critical and will be extra critical for two-sided boards which is what he’s working on now. We think if you put some scored carrier edges around the board with fiducials, you could make a jig that would hold the board in a very precise position using the holes in the carrier edges.

Vias are another issue. He mentions using rivets, but we’ve also seen people simply solder both sides of a wire through a hole, which isn’t that hard.

For most people, making your own PCBs is fun but not very practical. But there is something about being able to turn around actually good-looking boards multiple times in a day when you are doing heavy development. If you don’t mind fumes, you can laser mark your PCBs.

According to [ClassicHasClass], the best way to open an Atari Stacy is to not open an Atari Stacy. Apparently, these old computers were not pleasant to work on. The cables were not keyed and were prone to short against things. Screws easily strip out plastic holes. Of course, there wouldn’t be a story if there wasn’t a teardown and an upgrade that you can check out in the post.

The Stacy was one of Atari’s earliest portable systems and the first ST portable (that is, STacy). There’s a backlit LCD, a keyboard and trackball, and the usual ports. You could make do with a single floppy or spring for a second floppy or an internal SCSI hard drive. The 8 MHz 68000-based machine would set you back north of $2,300 back in 1989.

The original plan was to run the thing on C-cell batteries, but that would give you about 15 minutes of operation. They finally decided it was a luggable — you’d have to plug it into the wall. The battery compartment was there, but empty and glued shut.

Apparently, there were about 35,000 of these made, but they seem somewhat rare. But we do like a rare retrocomputer. Or even some that aren’t so rare.

We see many 16-bit retrocomputers around here based on Intel and Intel-like chips such as the 8086, 8088, V20, and similar. While they don’t seem very powerful by today’s standards, they were perfectly capable machines and, thanks to Elks (Embeddedable Linux Kernel Subset), you can run something fairly Linux-like on these devices.

The requirements are light: 512K of RAM is desirable, but you can do something with 256K. If you have ROM, you can even get by with 128K. Most importantly, the system doesn’t require a memory management unit to remap memory like many operating systems.

The project has been around for a bit, but has had some recent updates both for the runtime and the build system. For example, you can now build under WSL or using the Open Watcom C compiler. Executables are now compressed, and there’s a new cache system. The kernel and standard library no longer use long division, to improve perfomance.

If you want to try the system, you can boot it in an emulator on your browser. Just log in as “root.” There’s even a fake serial port available. Plus you can play Adventure. Or Doom.

We’ve seen Elks in some very strange places. Really strange.

In a stunning example of the Baader Meinhof effect, we’ve recently heard several times this week about events like the “carbage run.” That is, a motoring event where you can only buy some garbage car to compete. In the case of [Robbe Derks], the idea was to take a six-day journey to the polar circle in a car. But not just any car. It had to be at least 20 years old and cost less than €1000. That wasn’t hard enough for [Robbe] and friends. They also decided to make the car self-driving.

If you have a car that is new enough, this might not be as hard as it sounds. The OpenPilot project adds L2 self-driving features to about 275 car models. But probably not a 20-year-old junker or, in particular, a 1993 Volvo 940. [Robbe] took up the challenge and is doing a series of blog posts covering how it all worked.

Most (or maybe all) cars in 1993 didn’t have actuators for remote steering, so the car needed a transplant from a 2020 Toyota Corolla part. Adaptive cruise control also needed some help in the brake system. Add an accelerator servo and an optional radar sensor and you are almost ready to go.

We are waiting for more blog posts to tell us just how close to ready you are at that point. But even the first post has a lot of cool car info. It won’t be a weekend project to duplicate, but it does have a certain cool factor.

Now add a decidedly non-1993 Android phone… If you want to start with something less complex, maybe settle for driving assistance only in certain conditions.

From the Institute of Computing Technology division of the Chinese Academy of Sciences and Peng Cheng Laboratory comes a high-performance and well-documented RISC-V core called XiangShan.

In the Git repository, you’ll find several branches including at least two stable branches: Yanqihu and Nanhu. The currently developed architecture, Kunminghu, is impressive, with a sophisticated instruction fetch unit, a reorder buffer, and a register renaming scheme.

The point of these types of circuits in a CPU is to allow multiple instructions to process at once. This also implies that instructions can be executed out of order. A cursory glance didn’t show any branch prediction logic, but that may be a limitation of the documentation. If there isn’t one, that would be an interesting thing to add in a fork if you are looking for a project.

On the computing side, the processor contains an integer block, a floating point unit, and a vector processor. Clearly, this isn’t a toy processor and has the capability to compete with serious modern CPUs.

There is a separate GitHub for documentation. It looks like they try to keep documentation in both Mandarin and English. You can also find some of the academic papers about the architecture there, too.

We love CPU design, and this is an interesting chance to contribute to an open CPU while there are still interesting things to do. If you need to start with something easier, plenty of small CPUs exist for educational purposes.

There’s an old joke: What do you get someone who has everything? A place to put it. For hackers like [Christian], everything is a hoard of priceless electronic components. His solution is using small zipper bags, either regular plastic or anti-static. These attach using hook and loop fastener to plastic binder sheets which then live in a binder. Combined with some custom printed labels and a few other tricks, it makes for a nice system, as you can see in the video below.

Honestly, we’ve done something similar before, using a binder with little pockets, but the bag and custom labels beat our system. He even has QR codes on some of them to locate data sheets easily. Seems like a barcode for inventory management might have been good, too.

Some advice from us. If you are just starting out, this might seem like overkill. But if you start out doing something — this or something else — then ten years from now, you won’t have to be like us and think, “I’d get everything organized, but it is going to take months to work through what I already have…” That usually makes it a project you never really get started with. Develop good habits early!

Even if you don’t want to store your components this way, his binder hacks probably work for lots of other things, too. It isn’t as flashy as some systems we’ve seen, but it is very practical. If only you didn’t have to turn the pages in the binder yourself.

There aren’t many people who could do an hour-long video reviewing an oscilloscope, but [Kerry Wong] is definitely one of them. This time, he’s looking at a UNI-T MSO2304X 300 MHz scope. The review might be a little long, but the scope — like many modern scopes — has a lot of features for measuring power, accommodating digital signals with an add-on pod, and protocol decoding.

The scope has a touchscreen and four normal inputs, plus two frequency generator outputs. You can also use a mouse or an external display. But, of course, what you really want to know is how the scope performs when reading signals.

Thanks to its 5 GSa/s sampling rate, this 300 MHz scope was still able to handle much higher frequencies. Of course, the amplitude isn’t meaningful as you go over the limit, but sometimes, you just want to see the shape of the signal.

[Kerry] has promised a teardown video for this scope soon, and we’ll be watching for it. He sure knows his way around a scope. The scope reminded us a bit of our Rigol DHO924S, and we wondered how its trigger modes compare with this scope.

[Maker’s Fun Duck] has a recent video review of a cheap thermal camera from a company called Kaiweets, which you can see below. It checked all of his boxes: It was standalone, handheld, cheap, and not too cheap. The question is: does it work well for the kinds of things we would do with such a camera?

That’s a tricky question, of course, because everyone’s uses are different. Considering a soldering iron. A tiny one is great for working on PCBs, but lousy for soldering large coax connectors. A soldering gun works well for that purpose, but is too much for the PCB. The same goes for thermal cameras. Some are great for, for example, finding leaky parts of houses, but might not be so great at locating defective components on a PCB.

[Duck] starts out looking at coffee cups and hand prints. But he quickly moves on to printed circuit boards like a 3D printer controller. He also provides a number of tips on how to get accurate readings.

He seems to like the camera. But your use case might be different. There are some advantages to having cameras connected to your phone, for example, and there are other considerations. The camera appears to have a 256×192 resolution and can connect to a PC. It retails on the street for around $250.

Small cameras are valuable, even if you need to cable them to a phone. Like many things, thermal cameras get better and cheaper every year.

When you think of making something using a lathe,  you usually think of turning a screw, a table leg, or a toothpick. [Uri Tuchman] had a different idea. He wanted to make a clock out of the gears used in the lathe. Can he do it? Of course, as you can see in the video below.

Along the way, he used several tools. A mill, a laser cutter, and a variety of hand tools all make appearances. There’s also plenty of CAD. Oh yeah, he uses a lathe, too.

Initially, the clock ran a little fast. A longer pendulum was the answer, but that required the clock to sit on a table edge because the pendulum now extends below the bottom of the clock!

We have to admit there is a lot going into this, but it looks great by the time it is done. We are impressed with the range of different tools used and the clever design. Of course, he could have made the gears, too, but using the metal gears already available is a nice touch.

You can, of course, get by with less. Much less. Or, you might elect to try something even more elaborate.

Many things have combined to make very high-frequency RF gear much more common, cheaper, and better performing. Case in point: [dereksgc] is tearing apart a 20 GHz low-noise block (LNB). An LNB is a downconverter, and this one is used for some Irish satellite TV services.

The scale of everything matters when your wavelength is only 15 mm. The PCB is small and neatly laid out. There are two waveguides printed on the board, each feeding essentially identical parts of the PCB. Printed filters use little patterns on the board that have particular inductance and capacitance — no need for any components. Try doing that at 2 MHz!

The LNB is a single-band unit, so it only needs to worry about the two polarizations. However, [dereksgc] shows that some have multiple bands, which makes everything more complex. He also mentions that this LNB doesn’t use a PLL, and he’d like to find a replacement at this frequency that is a bit more modern.

After the teardown, it is time to test the device to see how it works. If you want to experiment at this frequency, you need special techniques. For example, we’ve seen people try to push solderless breadboards this high (spoiler: it isn’t easy). Maybe that’s why many people settle for modifying existing LNBs like this one.

When you think of languages you might read about on Hackaday, COBOL probably isn’t one of them. The language is often considered mostly for business applications and legacy ones, at that. The thing is, there are a lot of legacy business applications out there, so there is still plenty of COBOL. Not only is it used, but it is still improved, too. So [Meyfa] wanted to set the record straight and created a Minecraft server called CobolCraft.

The system runs on GnuCOBOL and has only been tested on Linux. There are a few limitations, but nothing too serious. The most amazing thing? Apparently, [Meyfa] had no prior COBOL experience before starting this project!

Even if you don’t care about COBOL or Minecraft, the overview of the program is interesting because it shows how many things require workarounds. According to the author:

Writing a Minecraft server was perhaps not the best idea for a first COBOL project, since COBOL is intended for business applications, not low-level data manipulation (bits and bytes) which the Minecraft protocol needs lots of. However, quitting before having a working prototype was not on the table! A lot of this functionality had to be implemented completely from scratch, but with some clever programming, data encoding and decoding is not just fully working, but also quite performant.

Got the urge for Cobol? We’ve been there. Or write Minecraft in… Minecraft.

[Den Delimarsky] had a Stream Deck and wanted to be free of the proprietary software, so he reverse-engineered it. Now, he has a Stream Deck Plus, and with the same desire, he reverse-engineered it as well.

The device has eight buttons, a narrow screen, and four encoder dials. The device looks like a generic HID device to the host machine, and once it has been configured, doesn’t need any special software to function. By configuring the device using the official software in a virtual machine under the watchful eye of Wireshark, it was possible to figure out how that initial setup worked and recreate it using a different software stack.

If you’ve never done this kind of thing before, there is a lot of information about how to find USB data and draw inferences from it. The buttons send messages when pressed, of course. But they also accept a message that tells them what to display on their tiny screen. The device screen itself isn’t very big at 800×100.

[Den] packages everything up in the DeckSurf SDK, an open source project that lets you control Stream Decks. So if you just want to control the Deck, you don’t need to know all these details. But, for us, that’s where the fun is.

Way back in 2015, we covered some guy who had sniffed out a USB signal generator. That was easy since it was a serial port. However, you can go pretty far down the rabbit hole.

Over the last few decades, electronic devices have drastically changed. Radios that once had point-to-point wiring gave way to printed circuit boards with through-hole parts, and now microscopic surface mount devices are the norm. But most of us still use probes that would have been just fine for a 1940s receiver. There are other options, of course. Among other things, you can now buy meters that have built-in tweezer probes. While not the first, the FNIRSI LCR-ST1 are affordable, and [TheHWcave] puts them to the test in the video below.

The tweezers come with two different pointy ends. It is more or less one of those testers that can identify and measure various components. Instead of the customary socket, this one has tweezer ends and, perhaps, a few extra functions.

The device can use several different voltages and frequencies while actively probing. Comparing some readings to a few other meters showed a bit of error, although nothing too drastic. The inductance reading of a very small inductor at 1 kHz was, however, too unstable to be useful.

The only downsides noted were that the probes could be a bit sharper for fine PCB work, and the display doesn’t rotate for left-handed operation. Both of those are probably fixable with a file and a firmware update. Overall, it looks like a reasonable low-cost tool.

Tools like this have been around for a while, but often at a higher cost. There are plenty of sophisticated test probes if you ever decide to look for them.

Most people know about the numerical constant pi (or π, if you prefer). But did you know that pi has an evil twin represented by the symbol ϖ? As [John Carlos Baez] explains, it and its related functions are related to the lemniscate as pi relates to circles. What’s a lemniscate? That’s the proper name for the infinity sign (∞).

[John] shows how many of the same formulas for pi also work for the lemniscate constant (the name for ϖ). Some  (as John calls them) “mutant” trig functions use the pi-like constant.

Mathematically, a circle is a point (the center) with a curve that describes x2+y2=r2. The lemniscate is a particular instance of a Cassini oval where r2=cos2θ. We all know the circumference of a circle—basically, the perimeter—is 2π; the perimeter of the lemniscate is 2ϖ.

Why does any of this matter? Well, [John] shows how it connects to elliptic curves and the Gauss constant.

Like pi, the lemniscate constant probably never ends, but it is roughly 2.622057. Will this be useful in your next project? Probably not. Will it help you win some bar bets? Maybe.

Then again, if you are bored calculating more digits of pi, here’s something new to try. Not that you need that many digits.

[Corelatus] said recently that “someone” asked them to identify the phone signals in the 1982 film The Wall, based on the Pink Floyd song of the same name. We suspect that, like us, that someone might have been more just the hacker part of the brain asserting itself. Regardless, the detective work is fascinating, and you can learn a lot of gory details about phone network in-band signaling from the post.

The analysis is a bit more difficult because of the year the film was made. At that time, different countries used slightly different tone signaling standards. So after generating a spectrogram, the job was to match the tones with known standards to see which one best fit the data.

The signal was not common DTMF, as you might have guessed. Instead, it was a standard known as SS5. In addition to the tones being correct, the audio clip seemed to obey the SS5 protocol. SS5 was the technology attacked by the infamous blue box back when hacking often meant phone phreaking.

The same phone call appears on the album, and others have analyzed it with some even deeper detective work. For example, the call was made in 1979 from a recording studio by [James Guthrie], who called his own phone in the UK, where his next-door neighbor had instructions to hang up on the operator repeatedly.

If you want to see and hear the entire clip (which has several phone-related audio bits in it), watch the video below. The sequence of SS5 tones occurs at 3:13.

Usually, when we hear tones in music, we think of Morse code. As for phone phreaking, we hear it’s moved to street kiosks.

Multiplication on a common microcontroller is easy. But division is much more difficult. Even with hardware assistance, a 32-bit division on a modern 64-bit x86 CPU can run between 9 and 15 cycles. Doing array processing with SIMD (single instruction multiple data)  instructions like AVX or NEON often don’t offer division at all (although the RISC-V vector extensions do). However, many processors support floating point division. Does it make sense to use floating point division to replace simpler division? According to [Wojciech Mula] in a recent post, the answer is yes.

The plan is simple: cast the 8-bit numbers into 32-bit integers and then to floating point numbers. These can be divided in bulk via the SIMD instructions and then converted in reverse to the 8-bit result. You can find several code examples on GitHub.

Since modern processors have several SIMD instructions, the post takes the time to benchmark many different variations of a program dividing in a loop. The basic program is the reference and, thus, has a “speed factor” of 1. Unrolling the loop, a common loop optimization technique, doesn’t help much and, on some CPUs, can make the loop slower.

Converting to floating point and using AVX2 sped the program up by a factor of 8X to 11X, depending on the CPU.  Some of the processors supported AVX512, which also offered considerable speed-ups.

This is one of those examples of why profiling is so important. If you’d had asked us if converting integer division to floating point might make a program run faster, we’d have bet the answer was no, but we’d have been wrong.

As CPUs get more complex, optimizing gets a lot less intuitive. If you are interested in things like AVX-512, we’ve got you covered.