The electronics-design layer of the tree — the physical board underneath the firmware. For thirty years a schematic was something you drew in a GUI; now it's something you write, diff, version, and compile. This hub maps the EDA toolchain (capture, layout, simulation), the fab partners that turn a design into a panel of boards, and the new code-defined PCB tools — led by Diode — that make a circuit a software artefact a coding agent can reason about.
Three bands — code-defined design (the new layer), the established EDA suites it builds on, and the fab/manufacturing partners at the end of the pipeline. All six are live explainers now — Diode plus the EDA suites it builds on and the fab partners it ships to. Each card maps to a leaf in tech/hardware/*.
The open-source EDA suite the rest of this branch builds on — schematic capture, PCB layout, 3D viewer, and the .kicad_pcb file format that Diode emits. Free, cross-platform, and the default for cost-sensitive and open-hardware work.
The commercial heavyweight — unified schematic, layout, and supply-chain data in one tool, with the high-speed and rigid-flex features serious product teams pay for. The benchmark Diode and KiCad get measured against.
Browser-based, collaborative EDA with an AI copilot baked in. The "Figma for circuit boards" pitch — real-time multiplayer design, component search, and an assistant that drafts schematics from a prompt.
The low-cost prototype fab that made hobby and startup hardware viable — upload Gerbers, get five boards in a week for the price of lunch. Integrated assembly (SMT) and a parts library that the design tools increasingly target directly.
The other major prototype-to-production fab — broader process options (rigid-flex, advanced HDI, metal-core), full turnkey assembly, and a path from a single prototype to a production run without changing vendors.
The thread running through this whole branch is the same one that reshaped software twenty years ago: take something that lived in a binary GUI file and make it text. Once a schematic is code, it gets everything code gets — version control, pull-request diffs, reusable modules, CI checks, and an LLM that can read and write it. Diode's Zener is the clearest expression of the pattern.
A traditional schematic is a drawing locked in a tool's binary format — you can't grep it, you can't diff it meaningfully, and you certainly can't reuse a power-supply block by importing it. Zener describes the same circuit as a hierarchy of nets, components, and modules. A reviewer sees exactly which two nets changed; a build server runs electrical-rule checks on every push; a reference design becomes an import.
# power.zen — a reusable 3V3 regulator module load("@stdlib/interfaces.zen", "Power", "Ground") vin = Power("VIN") v3v3 = Power("3V3") gnd = Ground() # Components carry their footprint + pin map Component( name = "U1", mpn = "AMS1117-3.3", footprint = "SOT-223", pins = { "VIN": vin.NET, "VOUT": v3v3.NET, "GND": gnd.NET }, )
That module compiles to a KiCad layout, drops into any board with one load(), and reviews like any other code change. It's the same move PlatformIO made for firmware and Drizzle made for database schemas — the design becomes the source, and the GUI becomes a viewer.
Electronics is the bottom of the stack — the board everything else runs on. It hands off upward to firmware (the code that runs on the silicon you just designed), sideways to the AI agents that now help design it, and outward to the partner hardware that 2nth ships. These are the branches it touches most.