Breadboard.ing: Fritzing for the Web Is Finally Here

The Breadboard Diagram Tool the Maker Community Has Been Waiting For

I still remember the first time I opened Fritzing to document a circuit I'd been prototyping for weeks. The drag-and-drop interface, the satisfying snap of a component onto a virtual breadboard — it felt like magic. But that magic has been wearing thin lately. Fritzing is slow, occasionally buggy, and despite a community rescue from years of neglect, it still feels like software that belongs to a different era of the internet. So when I heard that Scott Shawcroft — the CircuitPython lead at Adafruit — had quietly launched a web-based alternative called breadboard.ing, I dropped everything to try it.

This isn't just a tool announcement. It's a signal that the maker community's tooling is finally catching up to the ambition of the hardware it supports. Let me walk you through what breadboard.ing is, why it matters, and what it means for hobbyists, educators, and professional makers alike.

What Is Breadboard.ing and Why Does It Exist?

Breadboard.ing (yes, the domain is breadboard.ing — clever use of Google's ownership of the .ing TLD, which keeps domain costs surprisingly low) is a browser-based circuit diagramming tool inspired by Fritzing. You can drag virtual components onto a virtual breadboard, connect them with wires, and generate a shareable URL that encodes the entire state of your board in the hash of the link.

The project grew out of a specific engineering need: Scott is building a hardware-in-the-loop (HIL) testing board for CircuitPython development. The concept behind HIL testing is elegant — you plug the device you want to test (the "device under test," or DUT) into a harness board that manages power, connectivity, and communication. That harness then exposes everything over a network, so automated tests can run against real hardware without anyone physically touching it.

To configure which board is plugged in and how it's connected, Scott wanted something visual. A drag-and-drop interface where you could place a digital representation of a board onto a harness and immediately see which pins map to which connections. Fritzing was the obvious inspiration, but a native desktop app felt like the wrong solution for something meant to live on a network-accessible status page. So he built it for the browser instead.

The result is a genuinely useful tool even outside of HIL testing. If you've ever tried to explain a wiring diagram to someone over Discord, you'll immediately understand the appeal of a shareable URL that renders a live, interactive breadboard layout.

How the Tool Actually Works

The core interaction model will feel instantly familiar to anyone who has used Fritzing. You search for a component — a half-size breadboard, an Adafruit CLUE board, a STEMMA connector — and drag it onto the canvas. The tool automatically detects which breadboard rows each pin connects to and displays those connections in a panel below the canvas.

One of the smartest design decisions is the URL-as-state approach. Every component you place and every wire you draw is encoded directly into the page URL. Want to share your wiring diagram with a friend? Copy the URL. Want to embed it in a learn guide or a GitHub README? The URL is your embed. There's no account required, no file to export, no cloud storage to manage. The diagram lives in the link itself.

For those coming from KiCad workflows, there's also an import path worth knowing: Scott has been working on a KiCad-to-Fritzing converter that generates .fzpz files (the Fritzing component format) from KiCad board files. You can then drag and drop those .fzpz files directly into breadboard.ing. The pin naming isn't perfect yet — KiCad stores component labels more in the silkscreen layer than in structured data fields, so some manual cleanup is still needed — but the basic flow works and it's getting better.

The project is open source and lives at chanut.github.com/chanut/breadboarding. If you have a feature you'd love to see, the invitation is open: fork it, vibe-code something in, and send a pull request.

The Role of Local LLMs in Building This

Here's something I find genuinely fascinating about how breadboard.ing was built: almost the entire frontend was developed through LLM-assisted coding, and Scott has been deliberately moving away from proprietary models toward open-source alternatives.

Recently he's been experimenting with DeepSeek V3 (Flash variant) via Ollama Cloud — a $20/month subscription — and Qwen 3 (27B parameter version) running locally on a laptop loaded with 96GB of RAM. The RAM was originally purchased last summer for OpenStreetMap data processing, but it turns out that buying RAM before prices spiked was one of the better accidental investments a maker-developer could make.

The reasoning behind preferring local and open models isn't just philosophical. Scott lives in Seattle, where Seattle City Light sources power almost entirely from hydroelectric generation. Running inference locally on green power feels meaningfully different from routing every API call through a data center running on a less favorable energy mix. Tools like Electricity Maps make this carbon intensity visible in real time — France sits around 21g CO₂/kWh thanks to nuclear and hydro; some US data center corridors are many times higher.

For the maker and open-source community, this framing matters. The tools you use to build things have a footprint, and choosing local models running on renewable energy is a meaningful, practical choice — not just an ideological one.

CircuitPython, the CLUE Board, and Why Open Source Hardware Matters

If you're new to the Adafruit ecosystem, a quick orientation: CircuitPython is a beginner-friendly variant of MicroPython that makes embedded programming dramatically more accessible. When you plug a CircuitPython board into your computer, it shows up as a USB drive. You edit code.py in any text editor. The board runs it immediately. No compiler, no IDE, no upload step.

The Adafruit CLUE — one of the boards Scott demonstrated — is a great example of what this ecosystem can do. It shares the same physical form factor as a BBC micro:bit, so it fits all the same accessories, cases, and educational materials. But it runs a more powerful Nordic nRF52840 chip, includes a color TFT display, and supports the full CircuitPython library ecosystem. For educators who've invested in micro:bit infrastructure, the CLUE is a compelling upgrade path.

The broader point is this: Adafruit's business model — selling well-documented, open-source hardware — is what funds projects like CircuitPython and, indirectly, tools like breadboard.ing. When you buy a board from adafruit.com, you're not just getting hardware. You're funding the learn guides, the library maintenance, the deep-dive livestreams, and the tooling that makes the whole ecosystem easier to use.

Web Serial in Firefox: A Quiet but Important Win

Buried in the stream but worth highlighting: Firefox now supports the Web Serial API. This is a big deal. Until recently, tools like the CircuitPython installer — which uses Web Serial to flash firmware directly from the browser — required a Chromium-based browser. If you were a Firefox loyalist, you had to switch browsers just to set up a new board.

That barrier is now gone. Phil Torrone and Limor Fried (Ladyada) at Adafruit worked directly with the Firefox team to get this across the finish line, and maker-community testing helped validate the implementation. There's one caveat: the File System Access API, which the installer uses to read local files (like Wi-Fi credentials), isn't fully implemented in Firefox yet. So flashing CircuitPython works; some configuration steps still need Chrome. But the direction is clearly right.

If you run a maker workshop or teach electronics to students who use diverse browsers, this is worth communicating. The days of "you must use Chrome for this" are numbered.

Getting Started with Breadboard.ing Today

If you want to try breadboard.ing right now, here's the shortest path:

1. Open your browser and navigate to breadboard.ing
2. Search for a component in the sidebar — start with a half-size breadboard to get oriented
3. Drag it onto the canvas and then search for a second component, like an Adafruit STEMMA sensor
4. Drop the sensor onto the breadboard — the tool will automatically show which rows each pin connects to
5. Draw a wire by clicking a pin and dragging to another connection point
6. Copy the URL — your entire diagram is now shareable

If you're coming from KiCad, download your board's .fzpz export (or generate one using a KiCad-to-Fritzing converter) and drag it directly into the canvas. The pin names may need some cleanup, but the geometry will snap into place.

The project is actively being developed. Wires still have some layering bugs. The bounding-box detection on custom boards isn't perfect. But as a foundations-are-solid, rough-edges-remain kind of tool, breadboard.ing already does something Fritzing never could: it runs in a tab, it shares with a link, and it gets out of your way.

The maker community deserves tooling that's as open and accessible as the hardware it documents. Breadboard.ing is a real step in that direction — and if Scott's pace of development is anything to go by, it's only going to get better.

Frequently Asked Questions

What is breadboard.ing and how is it different from Fritzing?

Breadboard.ing is a free, browser-based circuit diagramming tool inspired by Fritzing. Unlike Fritzing, it requires no installation, runs entirely in the browser, and encodes your circuit diagram in the page URL so you can share it instantly with a link. Fritzing is a native desktop application that, while recently revived by community maintainers, can be slow and cumbersome for quick diagrams.

Do I need an account to use breadboard.ing?

No. The tool requires no account and no sign-in. Your circuit state is stored entirely in the URL hash, which means your diagram exists as long as you keep the URL. There's no cloud storage, no login wall, and no data being sent to a server.

Can I import my KiCad designs into breadboard.ing?

Yes, with some caveats. You can use a KiCad-to-Fritzing converter to generate a .fzpz file from your KiCad board, then drag and drop that file directly into breadboard.ing. Pin names may not transfer perfectly because KiCad stores label data in the silkscreen layer rather than structured pin fields, so some manual editing may be needed. The feature is functional and actively being improved.

What is CircuitPython and which boards support it?

CircuitPython is an open-source variant of MicroPython developed and maintained by Adafruit. It's designed to make embedded programming accessible to beginners by presenting the board as a USB drive — you simply edit a Python file and the board runs it immediately. Supported boards include the Adafruit CLUE, Feather series, ItsyBitsy, QT Py, and many community-designed boards. A full list is available at circuitpython.org.

What is hardware-in-the-loop (HIL) testing for microcontrollers?

Hardware-in-the-loop testing is a methodology where a real hardware board (the "device under test") is plugged into a test harness that manages its power, inputs, and communication. The harness exposes the device over a network so that automated test suites can run against actual hardware — not just simulators. For CircuitPython development, this means catching hardware-specific bugs that would never appear in software-only testing. Scott's HIL board for the ESP32-P4 is designed to make this kind of testing accessible to the broader Adafruit development workflow.

Does the CircuitPython web installer work in Firefox now?

Partially. Firefox now supports the Web Serial API, which means you can flash CircuitPython firmware onto a board directly from Firefox without switching to Chrome. However, the File System Access API — used by the installer for tasks like setting Wi-Fi credentials from a local file — is not yet fully supported in Firefox. Basic flashing works; some advanced configuration steps still require a Chromium-based browser for now.