Hackaday Podcast 035: LED Cubes Taking Over, Ada Vanquishes C Bugs, Rad Monitoring Is Hot, And 3D Printing Goes Full 3D

If you want a single episode that captures the glorious, solder-scented weirdness of maker culture, Hackaday Podcast 035 is a strong contender. This is not a polite little tech roundup where everyone nods thoughtfully over incremental updates. This is a full buffet of blinking cubes, safer programming languages, radiation detectors, and 3D printers trying very hard to stop thinking in flat pancakes. In other words, it is exactly the kind of episode that reminds you why hardware hackers are some of the most delightfully stubborn people on Earth.

What makes this episode so memorable is not just the list of topics. It is the through-line. Every segment points to the same bigger idea: makers are always trying to push tools beyond their “official” job description. LEDs are not content being indicator lights, so they become immersive sculptures. A programming language is not just syntax, so Ada becomes a weapon against whole classes of bugs. Radiation monitoring is not reserved for labs anymore, so homebrew Geiger and scintillation builds start roaming the neighborhood. And 3D printers are no longer satisfied with stacking flat layers like a lazy lasagna. They want curves. They want motion. They want full 3D.

Why Hackaday Podcast 035 Still Feels Fresh

The original episode dropped in 2019, but the ideas inside it have aged surprisingly well. That is partly because Hackaday was doing what it does best: spotting experimental hardware trends before they looked inevitable. The show notes for Episode 035 reveal a packed lineup that included non-planar 3D printing, a clever water-meter OCR build, Padauk microcontrollers, multiple ambitious LED cube projects, several radiation-monitoring hacks, and a feature on why Ada deserves more respect in systems programming.

That variety sounds chaotic on paper, but in practice it works. Hackaday has always thrived on the collision between practicality and obsession. You might tune in for the flashy LED cube and stay for a discussion about toolchains, detector physics, or why the Z-axis on your printer deserves better than a glorified elevator job.

LED Cubes Taking Over: Because Flat Displays Are Apparently Too Boring

The LED cube portion of the episode is the kind of material that makes hardware people grin like cartoon villains. LED cubes are a classic maker project, but the builds highlighted around Episode 035 show how far the form had evolved. These were not just beginner cubes blinking through the same five patterns from 2008. These were polished, dense, and unapologetically overbuilt.

Miniature Madness and PCB Acrobatics

One of the standout builds was a tiny RGB cube that packed absurd complexity into a desk-sized object. The magic was not just in the animation but in the engineering restraint. Tiny one-millimeter RGB LEDs, ultra-dense routing, and a footprint that sounds more like jewelry than electronics all combined to create a build that felt impossible until you looked closely and realized somebody had simply out-stubborned reality. That is often the secret ingredient in great hacker projects.

Another featured cube leaned into aesthetics as much as electronics. A handmade cube built from custom matte-black four-layer PCBs with gold-plated pads turned the project into functional art. Each face used a raw LED matrix, and the whole assembly tucked an FPGA and power hardware inside a tidy enclosure. It was a reminder that maker projects do not have to choose between “beautiful” and “wildly technical.” Sometimes the prettiest object in the room is also the one hiding a terrifying number of solder joints.

When an FPGA Joins the Party

Then there was the cube powered by an ICEBreaker FPGA setup, which pushed the concept from “cool project” into “please stop showing off, the rest of us are trying our best.” With 64-by-64 panels on each face and tens of thousands of LEDs overall, the build demonstrated what happens when display ambition outruns what a general-purpose controller can comfortably juggle. The Raspberry Pi handled orchestration, while the FPGA pushed the panel signals without breaking a sweat.

This is why the “LED cubes taking over” theme works so well. The cube is no longer just a novelty. It is a playground for PCB design, power management, signal timing, animation, enclosure design, and pure visual drama. It teaches a lot, and it looks like science fiction while doing it. That is a hard combo to beat.

Ada Vanquishes C Bugs: The Quietly Serious Segment

Every Hackaday episode needs one topic that sneaks up on you. In Episode 035, that role belongs to Ada. At first glance, a segment about a programming language might seem like the spinach on the plate next to the LED-cube dessert. But it turns out to be one of the smartest parts of the whole episode.

The case for Ada is simple: if you are writing software for systems that matter, it helps to use a language that treats mistakes like actual problems instead of exciting opportunities for undefined behavior. Ada’s reputation rests on strong typing, explicit conversions, compile-time checks, run-time checks, and a general refusal to let developers casually wander into memory-safety disasters with their shoelaces tied together.

That matters because many of the ugliest bugs in C and C++ are not clever. They are boring, repeatable, and expensive. Buffer overflows, illegal memory access, off-by-one errors, and range violations are exactly the sort of bugs that can turn embedded software from “works on my bench” into “why is the robot trying to self-destruct?” Ada’s design philosophy is to catch more of that trouble earlier and more explicitly.

What makes this segment even more interesting now is how modern it feels. In recent years, memory-safe programming has gone from niche concern to mainstream security conversation. That makes Hackaday’s Ada detour feel less like nostalgia and more like an early signal. The episode was not just saying, “Hey, here is an old language you forgot about.” It was saying, “Maybe the industry should stop acting like safety and clarity are optional accessories.”

Rad Monitoring Is Hot: Geiger Counters, Scintillators, and the Maker Curiosity Engine

If LED cubes are the flashy extroverts of this episode, radiation monitors are the slightly unsettling geniuses in the corner. Episode 035 digs into both Geiger-tube and scintillator-based projects, and that distinction matters. A Geiger-Mueller counter is the classic portable radiation instrument most people recognize. It is straightforward, iconic, and wonderfully clicky. A scintillation detector, by contrast, takes a more nuanced route by converting radiation interactions into light and then reading that light, often with more sensitivity for certain applications.

The podcast’s linked projects showed the full spectrum of DIY ambition. On one end, there was a fairly accessible Geiger counter build that proved the concept is not mystical once you understand the tube, high-voltage supply, and readout chain. On the other end, there was a “warwalking” scintillation rig that combined a detector, photomultiplier setup, GPS logging, and mobile compute hardware to survey local radiation levels while out on a walk. That is such a perfectly maker sentence it almost writes itself.

What makes these projects compelling is that they sit at the intersection of curiosity and instrumentation. Radiation is real, measurable, and often misunderstood. Official guidance from public-health and regulatory agencies still relies on Geiger-Mueller detectors and scintillation instruments for different survey needs, which gives these DIY builds a reassuring connection to real-world measurement practice. Of course, the homebrew versions are not a replacement for professional protocols where accuracy and safety are critical. But they do reflect a serious truth: modern makers do not just want gadgets; they want data about the physical world.

And yes, there is also a little thrill involved. A detector that can reveal invisible activity in granite, road material, or old objects has a built-in dramatic flair. It is science with just enough mild existential spice to keep things interesting.

3D Printing Goes Full 3D: Finally, the Z-Axis Gets Respect

The episode’s non-planar 3D printing discussion is probably the most forward-looking part of the whole package. Standard fused deposition modeling is technically three-axis motion, but most of the time it behaves more like “2.5D.” The printer draws a flat layer in X and Y, then the Z-axis politely steps upward and waits for its next turn. Effective? Yes. Elegant? Not always.

Non-planar printing tries to change that by allowing toolpaths that curve through space instead of being locked into flat slices. The practical benefits are easy to understand. Curved top surfaces can look smoother because they avoid the classic staircase effect. Interlocking layer geometry may also improve mechanical behavior in some cases by redistributing stress more intelligently than flat-on-flat layering. In plain English: prettier parts, and maybe tougher ones too.

But the episode does not pretend this is easy. Once the nozzle starts moving in more complicated Z patterns, clearance becomes a real headache. Nozzle shape matters. Fan ducts matter. Z-axis speed and backlash matter. Suddenly the printer’s least glamorous axis becomes the star of the show, and it demands attention like a diva who has just discovered method acting.

That is exactly why this topic belongs in a Hackaday podcast. Non-planar printing is not just a feature request. It is a challenge to the assumptions baked into hobbyist FDM. Research and advanced development in additive manufacturing have continued exploring non-planar layers, true 3D tool paths, and more sophisticated geometry generation, but the hacker appeal is obvious even before the academic papers arrive. If a machine says it prints in 3D, makers naturally want to ask why it is spending so much time pretending the world is made of stacked placemats.

The Hidden Charm of the Side Quests

Episode 035 also benefits from the smaller stories orbiting the headline topics. A water meter reader built around an ESP8266 and a camera module showed how far clever software can stretch modest hardware. Instead of handing OCR off to a more powerful computer, the build processed low-resolution images, isolated digit regions, sampled strategic points, and added sanity checks based on the fact that the meter value should only rise gradually. That is the kind of practical engineering that makes you laugh a little because it is both scrappy and smart.

Then there were the Padauk microcontrollers: hilariously cheap parts with hilariously tiny SRAM budgets and limited peripherals. They are not “easy mode” chips. They are the sort of devices that force you to think carefully, program tightly, and maybe question some of your life choices. In a weird way, they complement the rest of the episode perfectly. Whether you are routing a cube, writing safer code, building a detector, or hacking a printer, the whole spirit of the show is about squeezing more capability from tools than anyone reasonably expected.

What the Episode Really Says About Maker Culture

Underneath the blinking lights and buzzy detectors, Hackaday Podcast 035 is about maturity in the maker world. Not “maturity” in the boring sense where everyone stops having fun and buys beige storage bins. Maturity in the sense that projects are becoming more interdisciplinary. A modern maker build often mixes firmware, mechanical design, manufacturing, data handling, user experience, and safety thinking. The LED cube is not just LEDs. The Geiger counter is not just a sensor. The Ada discussion is not just about syntax. Every topic in the episode hints at a community getting more ambitious and more capable.

That is why the episode holds together so well. It celebrates spectacle, but it respects the engineering underneath. It gives room to beautiful builds and nerdy fundamentals in the same breath. It says, essentially, that the coolest thing on your bench should also have a good reason for being built the way it was.

Conclusion

Hackaday Podcast 035 remains a terrific snapshot of hardware hacking at full tilt. The episode bounces from LED cube excess to software correctness, from radiation instrumentation to genuinely three-dimensional printing, without losing momentum. That sounds impossible, but it works because all the topics share the same DNA: curiosity, rigor, and a refusal to accept default limitations.

If you are into maker podcasts, embedded systems, LED art, Ada programming, Geiger counter projects, scintillation detectors, or non-planar 3D printing, this episode still delivers. It is informative, funny, and packed with the kind of ideas that make you want to open too many browser tabs and start a project you absolutely do not have bench space for. In other words, it is peak Hackaday.

Bench Notes: 500 Extra Words on the Experience Behind This Episode

What makes the themes in this episode feel so relatable is that they mirror the emotional rhythm of real bench work. A project like an LED cube never starts as “an LED cube.” It starts as a harmless thought. Maybe a sketch. Maybe one panel. Maybe a sentence that should set off alarm bells, like, “How hard could it be?” Three evenings later, you are arguing with trace widths, counting current budgets, and realizing that every nice-looking animation has to pass through the grim bureaucracy of wiring, timing, and power delivery. Then you finally dim the room, run the first clean pattern, and immediately forget all prior suffering. That is how these projects win.

The Ada portion of the episode lands in a different emotional register, but it is just as real. Anyone who has worked close to hardware knows the special dread of a bug that is both rare and catastrophic. The kind that appears once every fifty boots. The kind that vanishes when you add debug prints. The kind that makes you question whether electrons hold grudges. Hearing a discussion about a language designed to reduce whole categories of mistakes is oddly comforting. It does not sound glamorous, but after enough late-night debugging sessions, safety starts to look downright attractive.

The radiation-monitoring stories hit yet another familiar nerve: the irresistible urge to measure something invisible. Makers love hidden systems. Wi-Fi signal strength, room temperature drift, power usage, magnetic fields, packet timing, air quality, vibration, light leakage, you name it. Radiation monitoring fits perfectly into that instinct. A Geiger counter or scintillation rig turns the environment into a conversation. Suddenly a countertop, a roadside patch, or an old object is not just “there.” It is producing data. That shift from passive observation to active measurement is one of the great pleasures of DIY instrumentation.

And then there is non-planar 3D printing, which feels like the classic maker combination of elegance and inconvenience. The concept is beautiful. Of course a printer should move through space more naturally. Of course curved layers should help with surface finish and maybe strength. Of course the staircase effect should annoy us enough to do something about it. But the moment you try to make the idea real, every practical limitation stands up at once. Hotend geometry. collision risk. awkward firmware settings. the Z-axis moving like it just remembered it has knees. It is a perfect maker challenge because the promise is obvious and the implementation is fussy.

That is why this episode works on more than an informational level. It captures the feeling of building: optimism, overreach, clever fixes, occasional humility, and those rare moments when a machine finally does something that feels a little magical. Whether it is an LED cube glowing like a tiny alien monument, a safer language catching a bug before it escapes, a detector finding a hot spot, or a printer laying down a curve that looks almost impossible, the experience is the same. You push a tool past its usual boundary, and for a moment the world gets bigger.