As a technologist, hardware has always been my final frontier.

Things you can touch, things that create physical outcomes, these can have so much more power than software alone. But the cost of that power is complexity. Electrons don’t care about our ambitions. Circuits can be harder to debug than code. And even if everything works perfectly on the level of logic and voltage, you’re still managing the complexity of physical objects, their wiring, their position in space, and even their heat dissipation.

Building any product is hard, but building a hardware product is a superset of the basics of any product challenge, adding in the iron constraints of the physical world. It’s not enough to imagine how something looks: you have to also find a way to build it in a way that matches your imagination, while simultaneously accommodating all those physical constraints.

It’s work.

But also? It’s never been easier than it is today. I just built complete replacements for my heat pump controllers. I hated those dinky remotes. You couldn’t read them in the dark at all, and programming them was about as bad as anything you remember from the bad old days of VCRs.

I imagined something that would solve their UI problems, and integrate my heat pumps into my home automation system. I’m not an electronics engineer, but my dreams are now real. I’ve got five of these across the house.

Using open source code is a skill: knowing how to navigate repos and someone else’s code, understanding how to troubleshoot and navigate communities to get help, discerning between quality projects and junk… this experience is a hard-won component of being a modern software explorer. It can take you further than you might realize, past mere bits and into the land of electrons and atoms.

Of course: microcontrollers

Arduino was a revolution in developer experience.

Beginners could write simple C code and and have a physical computing experience within the space of five minutes.

But since the advent of Arduino, the landscape of microcontroller boards—components that can be programmed to emit and receive complex electronic signals—has exploded.

Boards of every scale and configuration are available today, from the size of a peanut butter and jelly sandwich all the way down to a postage stamp. Microcontrollers are the foundation of the hardware adventure, allowing infinite iteration of custom logic on inexpensive components. Different designs sport different connectors and accessories. There are also different chip architectures out there, and boards built around ESP32, or the new Pico W, even include WiFi and Bluetooth capabilities.

Unifying all of this are software ecosystems. Open source Arduino code exists to solve so many kinds of problems, from networking to button handling. Regardless of your board’s architecture, there’s usually a port of the Arduino environment you can use, opening up all that code for your project. If you prefer Python, the MicroPython and CircuitPython projects even offer an alternative to C/C++.

But the ecosystem doesn’t stop at software.

StemmaQT and Qwiic: an old standard with new strategy

I2C is a two wire serial data standard that dates to 1982. In practice, it looks and works a lot like USB: two more wires add power and ground, and you can chain dozens of devices together on a single bus.

For the typical hobbyist hardware tinkerer, the hardest challenge comes down to circuit design. Electronics is arcane, governed by both the laws of physics and decades of component lore. Building circuits means understanding how to use all of these to channel electrons consistently, without letting the magic smoke out. It means understanding how to adjust voltages, manage resistance, and do it all in a way that’s physically sturdy and manageable.

This is a tall order. I’ve never had the time or motivation to learn enough circuit design to build anything more complex than arrays of blinking lights.

But now, I don’t need to.

If you build modern software, you’re well-versed in composition: grab a handful of existing projects—a database here, a UI framework there, an HTTP library to round it all out—and arrange them together. You write your custom logic—the stuff unique to your project—and let other people’s code do work that’s common across all projects.

Thanks to I2C and a convenient cable standard—branded StemmaQT by Adafruit, and Qwiic by Sparkfun, two leading hobbyist component vendors—the same approach to composition is possible in an electronics project. Decide your requirements, and you can probably find a few boards you can quickly wire together—without soldering!—that will address your problem.

In the case of my heat pump controller:

• ESP32-based microcontroller with a built-in screen
• Light sensor, so I can automatically dim the bright lights
• Temperature and humidity sensor, so I can have real data about the actual temperature in the room
• Rotary encoder board, to make a dial for setting temperature and toggling power

All of that just plugs in via I2C. Each board, like a well-made library, abstracts its gnarly implementation details under the hood. You don’t worry about power management, or the details of how to interpret signals as input from a rotary encoder.

Instead, after wiring things together, you look up the example code for each component, and adapt it to your project. In the past, actually using these components could be something of a mystery. But now vendors go to great lengths to maintain supporting libraries and docs—developer experience sells!

Adafruit deserves special mention here: they have hundreds of useful, unique boards that support this compositional approach, and their supporting materials are just exhaustive.

Again, if you know how to apply open source code, you can do this.

From imagination to physical objects

Once you create a working circuit, you can take it all a step further: design and manufacture your own custom enclosures.

It’s really kind of nuts: for $500, you can buy an incredible, reliable 3D printer from Prusa. You can’t beat Prusa: the printers come out of the box working perfectly, they’re vertically integrated with Prusa’s excellent cross-platform slicer software, and the user community is among the most active and helpful of anything on the internet. At that price, its build volume isn’t mammoth, but it doesn’t have to be for electronics projects.

Open hardware vendors often provide 3D models of their products you can bring into a CAD program. With these models, it’s possible to design plastic cases with perfect accuracy, allowing you to mount and arrange the various boards in your project.

Best of all, iteration is fast and cheap. Trying a new version of a design takes only a few cents of material and time to print it. You can figure out quickly if your approach is working. Remember heat dissipation? Waste heat from the microcontroller was biasing my temperature sensor. It only took a couple evenings to find an iteration of the case that solved the problem (I moved both sensors to the top side of the enclosure).

There is a learning curve to 3D printing. It might be the steepest factor here, in fact. Like electronics, 3D printing also has constraints to manage: you have to work with both heat and gravity, and design your models with that collaboration in mind. The physics of how layers are deposited impacts the strength and durability of your output, so the orientation at which you print can have consequences. Choice of materials also matters. I found PETG to be the ideal material for this kind of work: it’s easy to work with and super durable. By contrast, the more common PLA was too brittle.

You’ll also want to pick up some CAD skills, but this is less painful and more fun than you might imagine. CAD seems to be the fine art of sketching simple flat shapes, pulling and pushing them into 3D objects, and carving away at small details. I couldn’t stand most of the affordable desktop CAD software—it feels icky, like using a poorly-aged Flash app in IE6. Then I found Shapr3D, for iPad.

This is some futuristic shit. You tap away with your Apple Pencil, on a tablet computer, drawing things out of your imagination. You nudge your sketches into models, which turn into prints. There’s something far more intuitive about this process than using keyboard and mouse. The positive future shock makes me delirious if I dwell on it.

Community is everything to learning emerging skills. Hobbyists are deeply engaged with 3D printing, and you’ll find help for everything from planning your models to debugging thermal drama with your prints.

I think you should try it

I’ve been dreaming of building my own electronics since I was a kid. I spent so many afternoons at Radio Shack, and even tried my hand at the occasional kit, with limited success. Every few years in adulthood, I’ve given it another try, observing a steady downward trend in difficulty.

I’m telling you: we’re at a special moment here. The labor savings of open source, the composability, the fun: all of it has come to hardware. You can build things that solve real problems for yourself. I first imagined my heat pump devices over a year ago, and I have been frustrated they didn’t exist every day since.

Now my dreams are real, and the largest energy consumer in the house can be automated and remotely controlled.

That’s amazing.