Open Source Hack Lets The Razer Nari Headset Work With Linux

October 21, 2025 by 20 Comments

The Razer Nari is a decent wireless headset, but it’s a little oddball—because it uses a bespoke USB dongle for pairing. This is all well and good if you’re using a supported configuration; plug it into a Windows PC, run the utility, and you’re good to go. If you’re a Linux user, though, you were out of luck—but [JJ] has just solved that problem.

The tool was created by reverse engineering the pairing protocol used by Razer’s own proprietary software. [JJ] figured out the necessary pairing command, and how to send it to both the dongle and the headset. The headset itself must be connected by a USB cable when initiating the pairing process.

[JJ] believes the tool should work with any Razer Nari and dongle variant. However, the Nari Ultimate and Nari Essential models are yet to be tested, with verification still required. However, the pairing commands were extracted from Razer’s own tool and don’t appear to differ so it should probably work across the board. Setup is still a little fussy, particularly to get both the Game Audio and Chat Audio outputs working under Linux. However, [JJ] has helpfully provided the necessary detail to get everything up and running with PulseAudio and PipeWire setups.

Proprietary hardware can be frustrating to work with at times, but that’s never stopped hackers from reverse engineering their way to success before. If you’ve got your own projects in this vein, don’t hesitate to notify the tipsline!

ASIC physical layout

The Entire Process Of Building An Open Source Analog ASIC

October 8, 2025 by 6 Comments

Our hacker [Pat Deegan] of Psychogenic Technologies shows us the entire process of designing an analog ASIC. An ASIC is of course an Application-Specific Integrated Circuit, which is basically just custom hardware. That’s right, “just” custom hardware.

Services such as those from Tiny Tapeout make it possible to get your hardware designs built. And tools such as those found in Tiny Tapeout Analog Design VM with Skywater 130 PDK make it possible to get your hardware designs… designed.

In the video [Pat] takes you through using xschem (for schematic capture) and magic (for physical layout) to design a custom ADC. We learn that when it comes to hardware you have the choice of many different types of FETs, and not much else. Capacitors are expensive and to be avoided. Inductors are verboten. Getting specific values for things (such as resistors) is pretty much impossible so you generally just have to hope that things come out in relative proportions.

Continue reading “The Entire Process Of Building An Open Source Analog ASIC” →

A Childhood Dream, Created And Open Sourced

October 7, 2025 by 12 Comments

Some kids dream about getting a pony, others dream about a small form factor violin-style MIDI controller. [Brady Y. Lin] was one of the latter, and now, with the skills he’s learning at Northwestern, he can make that dream a reality — and share it with all of us as an open source hardware project.

The dream instrument’s name is Stradex1, and it’s a lovely bit of kit. The “fretless” neck is a SoftPot linear potentiometer being sampled by an ADS1115 ADC — that’s a 16-bit unit, so while one might pedantically argue that there are discreet frets, there’s 2^15 of them, which is functionally the same as none at all. Certainly it’s enough resolution for continuous-sounding pitch control, as well as vibrato, as you can see at 3:20 in the demo video below. The four buttons that correspond to the four strings of a violin aren’t just push-buttons, but also contain force sensors (again, sampled by the 16-bit ADC) to allow for fine volume control of each tone.

A few other potentiometers flesh out the build, allowing control over different MIDI parameters, such as what key [Brady] is playing on. The body is a combination of 3D printed plastic and laser-cut acrylic, but [Brady] suggests you could also print the front and back panels if you don’t happen to have a laser cutter handy.

This project sounds great, and it satisfies the maker’s inner child, so what’s not to love. We’ve had lots of MIDI controllers on Hackaday over the years — everything from stringless guitars  to wheel-less Hurdy-Gurdies to say nothing of laser harps galore — but somehow, we’ve never had a MIDI violin. The violin hacks we have featured tend to be either 3D printed or comically small.

If you like this project but don’t feel like fabbing and populating the PCB, [Brady] is going to be giving one away to his 1000th YouTube subscriber. As of this writing, he’s only got 800, so that could be you!

Continue reading “A Childhood Dream, Created And Open Sourced” →

Open Source Controller For Old And Expensive Industrial Robots

October 4, 2025 by 18 Comments
The Zynq-7000 usage at the core of the robot controller. (Credit: Excessive Overkill, YouTube)
The Zynq-7000 usage at the core of the robot controller. (Credit: Excessive Overkill, YouTube)

Industrial robots like robotic arms are basically everywhere, albeit usually out of the public’s eye in factories. This also means that they get replaced and scrapped all the time, making for many opportunities to snap up an industrial robot that once cost as much as a pretty fancy car for essentially peanuts. Over the years the bloke behind the [Excessive Overkill] YouTube channel did this a lot, which also revealed the main issue with these ‘cheap’ robots: the electronics and associated software, with the manufacturer rarely going out of their way to appease to hobbyists trying to fix up one of these units, never mind for free.

That said, if you’re persistent enough, you can reverse-engineer these beasts to the point where you can develop your own controller hardware and software solution. This is exactly what was done, resulting in an open source controller, found on the ExcessiveMotion GitHub page, that should allow you to control many of these industrial robots. At the core is a Zynq-7000 hybrid FPGA-ARM SoC chip, running real-time Linux (with preemptive scheduling patch) on the SoC side and custom HDL on the FPGA side to handle the hard real-time tasks.

The controller during testing. (Credit: Excessive Overkill, YouTube)
The controller during testing. (Credit: Excessive Overkill, YouTube)

The controller is made to be modular, with a backplane that can accept various interface cards in addition to the current RS-485 and RS-422 interfaces that are commonly used in industrial settings, such as here for controlling the individual servo drives of the robots. To make assembly and testing interesting, the first controller and integration with a robot was made ready for display at the Open Sauce 2025 event, requiring things to be rushed along, including reverse-engineering the servo protocol for a small-ish industrial robot suitable for public display and use, as well as developing the kinematics for the robotic arm.

With the controller now demonstrated, clearly this is the perfect time to rush out and get one of these fun industrial robots for a few hundred bucks. Currently the controller is still being finalized, with the author asking for feedback on what it should be able to support. If you have a particularly unusual industrial robot lounging around without the requisite controller, this might be your chance to revive it.

Thanks to [Hans] for the tip.

Continue reading “Open Source Controller For Old And Expensive Industrial Robots” →

Building An Open Source Point Of Sale System

October 1, 2025 by 21 Comments

[Mukesh Sankhla] has been tinkering in the world of Point of Sale systems of late. His latest creation is a simple, straightforward kiosk system, and he’s open sourced the design.

The Latte Panda MU single-board computer is at the heart of the build, handling primary duties and communicating with the outside world. It’s hooked up to a touchscreen display which shows the various items available for purchase. As an x86 system, the Latte Panda runs Windows 11, along with a simple kiosk software package written in Python. The software uses Google Firebase as a database backend. There’s also an Xiao ESP32 S3 microcontroller in the mix, serving as an interface between the Latte Panda and the thermal printer which is charged with printing receipts.

It’s worth noting that this is just a point-of-sale system; it executes orders, but doesn’t directly deliver or vend anything. With that said, since it’s all open-source, there’s nothing stopping you from upgrading this project further.

We’ve featured other interesting point-of-sale systems before; particularly interesting was the San Francisco restaurant that was completely automated with no human interaction involved Continue reading “Building An Open Source Point Of Sale System” →

A camera-based microscope is on a stand, looking down towards a slide which is held on a plastic stage. The stage is held in place by three pairs of brass rods, which run to red plastic cranks mounted to three stepper motors. On the opposite side of each crank from the connecting rod is a semicircular array of magnets.

Designing An Open Source Micro-Manipulator

September 4, 2025 by 21 Comments

When you think about highly-precise actuators, stepper motors probably aren’t the first device that comes to mind. However, as [Diffraction Limited]’s sub-micron capable micro-manipulator shows, they can reach extremely fine precision when paired with external feedback.

The micro-manipulator is made of a mobile platform supported by three pairs of parallel linkages, each linkage actuated by a crank mounted on a stepper motor. Rather than attaching to the structure with the more common flexures, these linkages swivel on ball joints. To minimize the effects of friction, the linkage bars are very long compared to the balls, and the wide range of allowed angles lets the manipulator’s stage move 23 mm in each direction.

To have precision as well as range, the stepper motors needed closed-loop control, which a magnetic rotary encoder provides. The encoder can divide a single rotation of a magnet into 100,000 steps, but this wasn’t enough for [Diffraction Limited]; to increase its resolution, he attached an array of alternating-polarity magnets to the rotor and positioned the magnetic encoder near these. As the rotor turns, the encoder’s local magnetic field rotates rapidly, creating a kind of magnetic gear.

A Raspberry Pi Pico 2 and three motor drivers control this creation; even here, the attention to detail is impressive. The motor drivers couldn’t have internal charge pumps or clocked logic units, since these introduce tiny timing errors and motion jitter. The carrier circuit board is double-sided and uses through-hole components for ease of replication; in a nice touch, the lower silkscreen displays pin numbers.

To test the manipulator’s capabilities, [Diffraction Limited] used it to position a chip die under a microscope. To test its accuracy and repeatability, he traced the path a slicer generated for the first layer of a Benchy, vastly scaled-down, with the manipulator. When run slowly to reduce thermal drift, it could trace a Benchy within a 20-micrometer square, and had a resolution of about 50 nanometers.

He’s already used the micro-manipulator to couple an optical fiber with a laser, but [Diffraction Limited] has some other uses in mind, including maskless lithography (perhaps putting the stepper in “wafer stepper”), electrochemical 3D printing, focus stacking, and micromachining. For another promising take on small-scale manufacturing, check out the RepRapMicron.

Continue reading “Designing An Open Source Micro-Manipulator” →

Microsoft BASIC For 6502 Is Now Open Source

September 4, 2025 by 29 Comments

An overriding memory for those who used 8-bit machines back in the day was of using BASIC to program them. Without a disk-based operating system as we would know it today, these systems invariably booted into a BASIC interpreter. In the 1970s the foremost supplier of BASIC interpreters was Microsoft, whose BASIC could be found in Commodore and Apple products among many others. Now we can all legally join in the fun, because the software giant has made version 1.1 of Microsoft BASIC for the 6502 open source under an MIT licence.

This version comes from mid-1978, and supports the Commodore PET as well as the KIM-1 and early Apple models. It won’t be the same as the extended versions found in later home computers such as the Commodore 64, but it still provides plenty of opportunities for retrocomputer enthusiasts to experiment. It’s also not entirely new to the community, because it’s a version that has been doing the rounds unofficially for a long time, but now with any licensing worries cleared up. A neat touch can be found in the GitHub repository, with the dates on the files being 48 years ago.

We look forward to seeing what the community does with this new opportunity, and given that the 50-year-old 6502 is very much still with us we expect some real-hardware projects. Meanwhile this isn’t the first time Microsoft has surprised us with an old product.

Header image: Michael Holley, Public domain.