A jumperless breadboard

Public Chat
Similar projects worth following
breadWare is a prototyping tool where jumper connections can be made by sending commands from a computer instead of placing physical wires.

The onboard ATmega4809 (now an AVR128DB64) can also read and write any analog (±9V) voltage anywhere on the breadboard.

That means with the right desktop app, you could prototype the circuits with someone else over the internet as if your boards were physically right next to each other. Or save a circuit on your computer and load it up later by just placing the components again. Or a million other things I haven't thought of yet.

You also can connect 5 (V3 now has 19, all 8 pins from port C and E, and 3 pins of port D which have a bunch of cool functionality) of the GPIO pins so you basically have an Arduino hidden inside a breadboard.

The connections are fully analog (internally a CMOS switch) and can handle ±9V (up to ±12V if you raised the supply voltages), with an on resistance of ~75Ω.

breadWare v0.2

My reason for doing this whole writeup and putting this out there is to hopefully find some fellow hackers who are equally stoked on breadWare and want to help make it into something where people will wonder how the hell they built anything before it existed (probably not Arduino levels of disruption, but when I need to use a Bus Pirate, I can't even imagine the horrible dystopian hellscape the world would be without it.) At least for me, placing jumpers messes up my flow, because there's always that angel on one shoulder telling me to be methodical: cut my jumpers to the right length, make nice 90° bends, use colors consistently, while the demon on the other shoulder says to just get the damn thing working now and let future me deal with the mess. The demon always wins, so I'd really like the angel to shut up, it's distracting. So offloading that internal debate to a computer seems like a good idea [disclaimer: do not run this on a HAL 9000 computer, I hear cognitive dissonance like this can cause undefined behavior]


Here’s the second board revision. I was showing off the last version to someone and they offhandedly mentioned that it would be cool if the whole thing fit under the breadboard. I knew this was my plan all along, but it forced me to finally design it before the code gets too specific to the original off-the-cuff design and I get stuck with my poor life design choices.

Matrix Board Changes



I found that the most valuable resource when finding paths between rows that aren’t directly connected (so they need to make an intermediate hop) are “virtual” breadboard rows that aren’t connected to the actual board but connect to the control board below and basically act as the general purpose nodes to do everything else (like reading voltages, connecting to the GPIO on the microcontroller, connecting to a second board, etc.). I put 4 of them in (on chips A, D, E, H), and I don’t think that’s nearly enough if I want to be able to do a bunch of special function things at once without making the user use some particular set of rows to do certain things. I would really like to make it as simple as “put anything wherever and the board will figure it out.”

I changed the logical arrangement of the MT8816 crosspoint switches to make the it easier to just hop over the middle space. In the original layout if I wanted to connect top row 5 to bottom row 5, it would always take 2 hops to do that (and these switches each have an on resistance of about 65Ω). Now the bottom rows are flipped so internally the bottom left is 62 and counts down to 33 on the right (note: these are abstracted away to the user by using b1-b30 instead of bigger numbers.)

And just to add some glam I added some reverse mounted LEDs that shine through the top and bottom power rails to show when that rail’s power supply is on.

Control Board Changes



I almost entirely redesigned the controller board so it has a ton of whatever the hardware equivalent of syntactic sugar is. The original was kind of thrown together to make sure the concept of using crosspoint switches like that wasn’t fundamentally stupid (still not entirely ruling that out, but so far it looks promising.) I also just realized I never did a writeup for the first iteration, and I’m not about to go back and do that just to prove that this board is an improvement.

Power Stuff

Because I’m going to such great lengths to make everything analog, and I already need a negative supply for the crosspoint switches; I decided to make the adjustable power supply for the rails also be able to do negative voltages. The power stuff still needs some work, right now it gets pretty warm when it’s running and it really doesn’t like it when I remove the matrix board with it on. Presumably because it needs some current draw but I’m not exactly sure why it cares as much as it does (I burned a tantalum cap shaped brand into my finger, you...

Read more »

Portable Network Graphics (PNG) - 595.07 kB - 07/10/2022 at 23:32


Adobe Portable Document Format - 358.29 kB - 07/10/2022 at 23:31


Portable Network Graphics (PNG) - 1.71 MB - 07/10/2022 at 23:31


Adobe Portable Document Format - 444.10 kB - 07/10/2022 at 23:31


Portable Network Graphics (PNG) - 2.43 MB - 07/10/2022 at 23:31


View all 16 files

  • 1 × AVR128DB64
  • 10 × MT8816 8x16 Analog Crosspoint Switch
  • 1 × LT1054 Charge Pump Inverter/Regulator
  • 1 × MCP2221A USB to UART
  • 2 × L272D Power Dual Op Amp

View all 7 components

  • New Project Page!

    Kevin Santo Cappuccio05/23/2023 at 20:53 0 comments

    If you want to see future updates for this project, the new project page for Jumperless is here:

    It's fundamentally changed enough that it's basically a new thing.

  • Control board routed!

    Kevin Santo Cappuccio07/21/2022 at 16:52 1 comment

    Phew, that was definitely the densest board I've routed. I was really close to simply running out of room and having to make it a 4 layer board and start over. 

    And here it is after removing one of the D's

    So I was talking to [Stephan Bourgeois] who is working on his really cool MicroMaster Mini (seriously, take a second to look at that firmware, it's ridiculously good and I'm super jealous) and he thought it would be nice to be able to plug it in to breadWare and get the much higher performance protocol analysis and injection stuff you'd get from a dedicated piece of purpose-built hardware. So I threw in another 20-pin card-edge connector that allows them to both speak UART to each other and route signals anywhere so we can eventually add support for that. 

    Also, I had forgotten about the chip shortage for a while until I was buying parts for this, and it turns out the MCP2221A UART-USB bridge might be impossible to get, so I added a footprint for the FTDI FT231XS just in case. The FT231X apparently wants resistors on the data lines while the MCP2221A doesn't, so I made a resistor footprint with bridged pads so we can have the option depending on which one gets populated. So hopefully I'm now half as likely to get screwed over by chip availability. 

    This thing should just come with an xacto knife for how many solder jumpers there are.

    Chip availability might also be a problem for the MCP4728 and MCP4661 but I decided I'm just going to hope for the best with those instead of covering the board in unpopulated footprints. 

    And it's not like I had a ton of extra room for that

    But it's finished, now I just need to do the top board (which will definitely be 4-layers, so it should be a little easier if I can get my brain to intuitively switch between 4 layers without having to think about it. 

  • Finally some progress on version 3!!!

    Kevin Santo Cappuccio07/10/2022 at 23:28 0 comments

    So it's been a while since I actually did anything on breadWare, but it's always been in the back of my mind and everything I've worked on since has been helpful in figuring out how I should approach this next revision.

    I haven't routed any traces yet so it's easy to change things, so if any of you Hackaday people see anything wrong (or even if you think something could be better) I would love to hear your armchair engineering.

    Here's a list of the things I changed from version 2:

    •  I'm using an AVR128DB64 as the microcontroller instead of the ATMEGA "Every-tool-just-kinda-forgot-to-support-me" 4809. I've been way into these new series of chips Atmel has been coming out with. And having all the documentation from is super nice. [Spence Konde] and [MCUdude] deserve a frickin' Nobel Prize.

    I managed to get a good deal of those peripherals on the left side connected to somewhere you can actually use them on the breadboard.

    • Every crosspoint switch is connected to every other one on the board directly (but now there's only 2 direct connections between each chip) and the 2 extra connections are each connected to the 2 (instead of one) special function chips on the control board. I'm pretty sure this is a better way to do it than Version 2 but most of the problems come out when writing the code to handle the connections. So instead of spending too much time trying to guess every pitfall beforehand, I'm just going to try it and see where the new problems arise. (Once again, suggestions will be lovingly welcomed)

    • Also every crosspoint (instead of only 4 of them) has an unconnected Y input because those were ridiculously useful to cover for times where there aren't enough direct connections or whatever. That also means there are 4 points on the breadboard that aren't connected to anything (which will probably be useful for sensitive/high voltage stuff) and their location is selectable with a solder jumper (corners or right side)
    • I redid the power supplies a bit to get +-8V from the 0-5V DAC. And I also connected one of those directly to the AVR128DB64's built in DAC so I can use it as a function generator. The datasheet says it can output at 120Ksps, so if everything works basically like it does in LTSpice, it shouldn't be that bad of an arbitrary waveform generator for this purpose. (But if there's some analog ninja out there reading this, please let me know if this is going to blow up if my face.)
    • The negative rails are directly connected to ground by default now because as I learned from the last version, switching grounds around with a ~65Ohm resistor in series sucks. And creating a "ground" by having a power opamp output 0V was a bad idea if you don't want it floating all over the place. But that can be changed to and adjustable voltage with yet another solder jumper. I went absolutely jumper crazy to avoid making any hard decisions.

    • Speaking of not making any decisions, I put an entire 20 pin card edge connector on the control board so if we ever decide to add current measurement (or anything else) we can populate it and throw in a little PCB to do that.

    I spent about a week trying to figure out a way to measure current from the power supplies that was simple and cheap enough to be worthwhile. There's definitely some way to do this without adding a ton of parts or one really expensive chip, but I figured I'd leave that up to future us to deal with and just route every signal we might need to a connector.

    • I also added 4 probe outputs so you can just plug in a few jumpers and make connections by poking 2 points like I originally wanted to do for version 2. Probe 1 connects to the inputs to one of the AVR128DB's internal op amps,  so there's a bunch of other things you'll eventually be able to use these probes for. 

    • The top board is now has holes to that line up with the holes on the back of a Jameco Valuepro breadboard so instead of painstakingly...
    Read more »

  • breadWare: The Movie

    Kevin Santo Cappuccio11/08/2021 at 11:49 0 comments

    Here's my explainer video for breadWare

    I hope it adds a little more clarity to what this thing does. Some (~40%) of the features I mentioned in the video haven't been coded yet. But we've been banging out a lot of code lately to make a majority of the things you see in this video real demos and not just lies.

  • Why not an FPGA?

    Kevin Santo Cappuccio06/22/2021 at 02:30 0 comments

    I've received this question a lot, so instead of answering it in random comment threads I'll just do it here. I'm referring to research I did a year ago and didn't bother to look anything up for this to get any hard numbers. Take the things I say here with a grain of salt, because to be honest I'm not particularly learned in the ways of the FPGA. But I did learn enough to know that I don't need to learn any more about them for this project (one day I will have a project that actually needs one and isn't just crammed in for no reason, and I'm looking forward to it)

    I considered something like this early on, but it turns out FPGAs won't work well for this particular use case. But on a super high level, breadWare is sort of an FPAA (Field Programmable Analog Array) built out of a bunch of discrete chips to make it work the way I had originally imagined they would. 

    Here are some fun facts about FPGAs (that weren't so fun when I learned them because it meant the design was going to be waayy more complicated):

    -Although we think of them as routing signals through a bunch of logic gates, how they actually work is by sending the signals through LookUp Tables, so it basically simulates a logic gate by just reading places in memory that you've programmed with a bitstream. The LUTs are connected by a crossbar switch internally, but they know exactly how it's going to be used so they can simplify out a lot of the things that would make it "general-purpose." From what I understand, the input signals always go through a large set of LUTs (which is fine in a purely digital world, because they can just map 1 to 1 and 0 to 0 ) before they can go through the crossbar switch. So it's more like a Star Trek teleporter where it just scans and reassembles you on the other side.

    -Nowadays it's really rare to find FPGAs with inputs that are even 5V tolerant, most are only like 2.8V tolerant, so you'd either need to be super careful with the connections or have 60 separate level shifters.

    -You need analog signals to make even the simplest of digital circuits work, for example a 555 timer needs to read the voltage on a capacitor to generate a clock signal.

    -I got really excited when I heard about FPAAs, but turns out they're basically unobtanium for less than $100 per chip, and they're usually only a few analog blocks thrown into a regular FPGA. Apparently JPL made a chip in-house for spacecraft, but I can't imagine a regular person could buy one.

    So now I have a microcontroller and a digital potentiometer do those extra things, and the ATmega4809 I'm using does have a built-in hardware logic gate they call a "Configurable Custom Logic" cell, as well as a ton of other fun things to mess around with.

    But yeah, an FPGA version could probably do some awesome things that this one can't.

  • Dual Matrix Test

    Kevin Santo Cappuccio06/16/2021 at 12:18 0 comments

    After seeing that a single MT8816 would work, I wanted to make sure you could route a connection through 2 of them and still have a reasonably good connection. Because using a single 32x32 crosspoint wasn't gonna happen, I think they actually might exist (it's been a while since I looked into it), but they're in the few hundred dollar range per chip, and they're generally for HDMI switching so they don't really have the qualities you'd want in a general purpose analog switch. 

    I also wanted to make it not take up the whole breadboard so I could actually test it on real things. 

    Disclaimer: what I wrote above is a lie, the real reason I made this is because I had just discovered the joys of wire-wrap wire and I needed an excuse to use it. 

    Here's the code

    What follows is basically a slideshow of me building this thing.

    This is the pinout for the rows of wires going to the Arduino Nano Every

    Control Lines (top to bottom)  (left side of board)

    CS A

    DAT A

    STB A

    RST AB

    CS B

    DAT B

    STB B

    Vdd +

    Vss GND

    Vee -

    Address Lines (left to right) (bottom of board)

    Y0 A

    Y1 A

    Y2 A

    X0 A

    X1 A

    X2 A

    X3 A

    Y0 B

    Y1 B

    Y2 B

    X0 B

    X1 B

    X2 B

    X3 B

  • Early Proofs of Concept

    Kevin Santo Cappuccio06/16/2021 at 11:40 0 comments

    Here are some photos and videos of early proofs of concept to make sure you could actually use a crosspoint switch to make a reasonable stand-in for a physical jumper. I was expecting this not to work, but surprisingly, it did. 

    Here's the 555 test setup. I'm using a DIP version of the MT8816 which was really handy for this early testing stuff. 

    and here it is working  here's the code for this

    What I'm doing here is using the crosspoint switch to change the resistors and capacitors in the 555 circuit to change the frequency.

    That other 8 pin chip on the left is a charge pump to make the -9v power rail.

    Then I realized I should probably do something more intuitive for the students so I set this up with LEDs 

View all 7 project logs

  • 1
    How I soldered a PCB onto a breadboard

    So I've been asked how I attached the breadboard to the PCB, the answer is that it was a pain in the ass.

    So in v0.1, I had those rows of plated through holes along the middle where I started by adding a blob of solder on each of those metal clips, then putting a fine tip on my soldering iron and sticking it through the hole from the other side to melt it and letting surface tension grab the PTH and bridge them together. It was a total hack that took forever and wasn't super reliable.

    On v0.2, I made those middle rows closer together to roughly line up with the inner edges of those metal clips. I tried a few different things, drilling a hole in each one and sticking a wire through (I used that for the power rails), using 90° header pins to grab them from the side but the one that ended up working the best was pulling the metal clips out of the plastic breadboard and cutting a tiny tab into the inner side of each clip, bending them 90° and using that as a pin to solder into the holes. The pins only go like halfway through so from the back they just look like flat pads of solder, but it seems to be enough. In the pictures I've only done one side.

    I should have taken more pictures of this process but getting those tabs to all line up perfectly straight and all fit at the same time was pretty finicky, and I never think to take photos when I really have to concentrate. It's weird because that means the easy parts are the best documented, and the parts people might have trouble following have almost none (you can see that effect in my code too, the function findPath() is ridiculously complicated and has 0 comments, sorry everyone)

View all instructions

Enjoy this project?



Stephan Bourgeois wrote 07/31/2022 at 13:07 point

I just found out about a program called SerialPlot here on hackaday. It allows you to plot serial data in real time. Its too easy to make BreadWare work with serial plot. I'm gonna make MicroMaster work with serial plot. Its gonna be awesome. So excited.

  Are you sure? yes | no

flapjackboy wrote 08/07/2021 at 22:40 point

Now, if someone could make a Fritzing plug-in that could route things automagically...

  Are you sure? yes | no

Electromaker wrote 07/01/2021 at 09:39 point

This is a wonderful project and I really hope you get others on board to help you take this further. We put the call-out on our weekly Youtube show:

  Are you sure? yes | no

Kevin Santo Cappuccio wrote 07/01/2021 at 11:30 point

Awesome, thanks! Your show is great, even when you're not talking about my stuff. 

  Are you sure? yes | no

Vitaly Domnikov wrote 06/24/2021 at 16:28 point

Super awesome project!  🚀
I did something similar, but a lot simpler that you did:

  Are you sure? yes | no

Alwyn Allan wrote 06/24/2021 at 07:44 point

Awesome concept and execution. It reminds me of the Cypress PSoC concept, which is still mind-blowing 20+ years after it was introduced. You use their PC-only GUI to sketch your analog + digital + software with a nice selection of on-chip OpAmps, DACs, ADCs, filters, and anything you care to connect to IO pins, and it routes it through CMOS switches to make it all work. Same on the digital side, and it gets implemented as logic with low-nanosecond latencies, not a software simulation. The CY8CKIT-059 is a good entry point for $15. No negative rails, but you're better off designing that way these days. 

  Are you sure? yes | no

John Loeffler wrote 06/23/2021 at 02:37 point

Love the project.  I have heard of allot of people wanting to make something like this but you are the first one to do it. 

  Are you sure? yes | no

Kevin Santo Cappuccio wrote 06/23/2021 at 03:11 point

Thanks man. Yeah it was super helpful to have hundreds of pages of forum posts for abandoned projects to get help get past some of those early gotchas. Weirdly enough, most of the useful ones revolved around routing guitar effects pedals. Maybe when this project is a bit more mature I'll send them some boards to thank them for being unwitting collaborators.

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates