At Assemlab, we’re building something that blends education, electronics, and hands-on learning — an 8-bit computer you assemble yourself, wire by wire, module by module. Think of it as the LEGO of computing, where each component is placed manually on our custom-designed breadboards, giving users the opportunity to understand how computers work from the ground up.

We created this kit, codenamed BitByBit, for both curious beginners and seasoned electronics enthusiasts. Whether you’ve never touched a breadboard before or you’re already soldering your own PCBs, BitByBit is designed to teach computing fundamentals in a way that’s visual, interactive, and deeply satisfying.

To validate the educational impact of the kit, we’re currently conducting a pilot study at TU Dresden with a group of 10 participants. Divided into five teams of two, each group has their own full kit and is being observed as they build, troubleshoot, and learn. The feedback is helping us refine the experience and ensure that BitByBit makes computing concepts truly accessible.

But as we started preparing the first batch of kits for this study, we ran into a practical problem: each kit requires nearly 1,000 jumper wires, all precisely cut and stripped on both ends. For just six kits, that meant 5,000 cables — and manually preparing them wasn’t scalable.

So I built a machine to do it for us.

As we prepared the first prototypes of the BitByBit kit, we quickly realized that manually cutting and stripping thousands of wires was not only time-consuming — it was a serious bottleneck.

We didn’t want to ship our kits with full cable spools and ask customers to cut everything themselves. That would shift the focus away from learning how the computer works, and instead turn the experience into a tedious cable prep session. Measuring, cutting, and stripping each wire requires energy, patience, and a surprising amount of time — especially when you need to do it nearly a thousand times per kit.

Manual cutting also lacks precision. It’s easy to end up with wires that are too long, too short, or stripped incorrectly — especially with short jumper cables, where removing insulation cleanly becomes much harder. These small inconsistencies add up and can lead to frustration during assembly.

That said, we still believe cable preparation can be a valuable part of the learning experience. For that reason, we plan to offer an optional version of the kit with full spools of wire for those who want to take on the extra challenge and cut everything themselves.

But for our pilot study, and for most users, we knew we needed something more polished — a kit with pre-cut, pre-stripped cables, ready to plug in. Unfortunately, ready-made wire cutting machines were far outside our budget as a small startup. So, we decided to build one ourselves.

From the very beginning, one of our main goals was to keep costs low. As a young startup, we didn’t have the luxury of buying industrial equipment — so we decided to build our own machine, using mostly 3D-printed parts and off-the-shelf electronics.

After briefly considering platforms like Arduino or ESP32, I chose to run the machine on a Raspberry Pi Zero 2W. It gave us the flexibility to write the software in Python, connect remotely over SSH, and benefit from greater processing power — perfect for logging, real-time feedback, and future upgrades.

The mechanical design follows a clear and modular logic:

1. The cable starts on a spool, mounted on a simple holder.
2. A stepper motor, controlled via a DRV8825 driver, pulls the cable forward.
3. The cable then passes through a rotary encoder, which verifies the movement and ensures the correct length is reached — a feedback loop that helps catch any skipped steps or mechanical slips.
4. After that, the cable goes through a manual wire stripper, mounted on a servo. The servo pulls the stripper handles to remove insulation from both ends.
5. Finally, the cable reaches a pair of standard wire cutters, also operated by a servo — performing the final cut.

To help detect the position of the cable and calibrate the start of each cycle, I added an optical slot sensor, which can detect the end of the cable with high accuracy.

A small OLED screen displays the current machine status or any warnings and errors. Users control the machine via a terminal-based interface, accessible through SSH. Upon launching the Python program, a menu allows operators to start cutting, change settings, or run diagnostics.

All the mechanical parts — from the cable guides to servo mounts and gear mechanisms — were modeled in Fusion 360 and printed in PETG and PETG-CF for strength and durability.

One of the unexpected challenges was power distribution. The stepper motor and cooling fan require 24V, the Raspberry Pi runs on 3.3V, and the servos and encoder require 5V. To keep everything running reliably, I built a custom power setup:

• A bench power supply (designed and built in-house) delivers the primary 24V to the system.
• A buck converter steps down 24V to 5V for the servos and supporting electronics.
• The Raspberry Pi receives regulated 3.3V through its onboard converter.
• To ensure signal compatibility between voltage domains, a logic level shifter converts 5V control signals to 3.3V for safe communication with the Pi.
• All power routing and signal conversions are soldered neatly onto a prototyping board integrated into the machine.

This was our Version 1 of the machine. It worked — but not perfectly. In the next section, I will go over the lessons I learned, and how I redesigned the machine to become faster, stronger, and more precise.

While first version of the machine was functional, it quickly revealed its limitations. As I began using it to cut real production cables, several issues emerged that made it clear I needed to rethink the approach.

One of the biggest problems was inaccuracy. Despite clamping the cable tightly, it would sometimes slip during feeding, and the machine couldn’t reliably detect the error. The cable was pulled using a NEMA 17 stepper motor, connected to 3D-printed wheels with custom silicone grips that I cast myself using printed molds. While creative, this solution lacked the precision we needed — and the softness of the silicone combined with the flexibility of the printed parts introduced too much tolerance.

Another challenge was the mechanical reliability. Nearly all components were made from plastic, including structural parts under significant mechanical stress. This caused flexing and loss of alignment over time.

And then there were the tools: our insulation removal and cutting system was based on manual wire strippers and cutters, actuated by servos. These tools weren’t designed for automation, and while they technically worked, they were slow, imprecise, and sometimes even damaged the cable. The servos often lacked the torque to fully cut through the wire, especially during repetitive operation.

So, I went back to the drawing board and built Version 2 — not just a fix, but a full redesign.

The mechanical system was completely re-engineered:

• I replaced all 3D-printed motion components with metal parts: GT2 belts, pulleys, ball bearings, and lead screws.
• The cable is now pulled using a filament extruder from 3D printer, connected to a NEMA 17 stepper motor. This extruder grips the cable firmly and feeds it with high precision.
• A GT2 belt connects the motor to a rotary encoder, providing accurate feedback on cable movement.
• After feeding, the cable passes through a slot sensor to detect its tip and prepare for stripping or cutting.

At the end of the cycle, the cable enters what I call the guillotine — a robust cutting and stripping mechanism built from the ground up:

• A pair of V-shaped blades form the cutting head — one fixed at the base, the other mounted on a movable platform.
• The platform is driven by another NEMA 17 stepper motor, connected to a lead screw via a flexible shaft coupling.
• Depending on how far the blade descends, the guillotine can either strip the insulation or fully cut through the cable in a single motion.

This new setup has proven to be extremely reliable and precise, even during long production runs.

Of course, building V2 came with its own set of challenges. I accidentally ordered faulty DRV8825 motor drivers — three in a row didn’t work, which delayed testing. In the end, I used an A4988 driver for the guillotine stepper and had to make some minor modifications to the control board to accommodate the different wiring.

Once we had a reliable way to cut and strip thousands of cables, another challenge quickly emerged: organization. It wasn’t enough to just cut wires — they had to be sorted correctly.

Our 8-bit computer consists of 14 different modules, each requiring its own set of cables in various lengths and up to seven different colors. Manually grouping these cables after cutting them would have been a massive task, especially at scale. So I decided to add another layer of automation: a cable sorting module.

The idea was simple in theory: as each cable exits the cutting machine, it slides down a ramp and falls into a large rotating wheel — like a lazy Susan — divided into 20 compartments. This wheel is connected to a servo motor, allowing the system to rotate it to a specific position before each cut. That way, each wire is dropped into the correct slot according to its length, color, or associated module.

While the concept worked and the prototype was functional, the sorting module introduced its own set of problems:

• The servo sometimes didn’t have enough torque to rotate the wheel precisely, especially when compartments were filling up with wires.
• Occasionally, the cables bounced out of the wheel entirely or landed between compartments, ending up in the wrong place.
• In some cases, they even jammed the rotation mechanism, causing the machine to stop.

Despite these issues, the current version of the sorting module still saves a lot of time and labor. But I now know that Version 2 of the sorting system will be necessary — with stronger actuation, better cable guidance, and a more secure bin design.

Until then, this sorting solution is good enough to keep production moving and our kits organized — one wire at a time.

Our current version of the cable cutting machine — combined with the prototype sorting module — has already transformed how we build and test our BitByBit kits. It’s allowed us to produce thousands of precisely cut and stripped wires quickly and reliably, accelerating both prototyping and user testing.

Version 2 serves as a solid foundation for what’s coming next.

I’m already planning Version 3, which will be optimized for daily production at scale. It will include:

• Automatic spool changers to switch wire colors without manual intervention.
• The ability to cut and sort multiple cables simultaneously.
• A redesigned and more powerful sorting system to handle large batch output with precision.

Once I resolve the final mechanical quirks and improve the sorting mechanism, I plan to release the entire machine as an open-source project — so that other makers, educators, and startups can benefit from it too.

The journey of building our own hardware — and the machines that make it — is just getting started.