KiCad is the open-source Electronic Design Automation suite — schematic capture in Eeschema, board layout and routing in Pcbnew, a 3D viewer, ngspice simulation, and a Python scripting API, all under the GPLv3 with no per-seat licence to buy. It's a professional-grade tool that costs nothing to run, which is why it's the floor of the 2nth hardware stack: the GUI engineers open after Diode compiles a design to .kicad_pcb, and the zero-licence path from idea to a board you can send to a fab.
KiCad is an open-source software suite for Electronic Design Automation — everything you need to take a circuit from a blank page to manufacturing files. It runs on Windows, macOS, and Linux, and it has been in development since 1992. The headline fact is the simplest one: it is professional-grade and it is free, released under the GNU GPL v3. There is no licence to buy, no seat to renew, and no feature tier locked behind a subscription.
Inside the suite are the tools an electronics engineer actually uses: Eeschema for schematic capture, Pcbnew for PCB layout and routing, a Gerber viewer for inspecting manufacturing output, an integrated 3D viewer, and a SPICE simulator built on ngspice. Behind those sit the symbol, footprint, and 3D-model libraries that supply the parts you place. It is the default answer to “what should I design a board in” for anyone who doesn't have an Altium budget — and increasingly for plenty who do.
KiCad is the open-source EDA suite. It does what Altium does — draw the schematic, lay out the board, push out Gerbers — without the licence cost. In the 2nth tree it's the layout surface Diode's pcb compiler emits to, and the free path SA hardware teams can actually start on.
For a long time, serious PCB design meant a serious licence. Altium and the other incumbents cost real money per seat per year — a fixed tax on the front door that priced out students, hobbyists, small teams, and anyone in a market where that bill lands in scarce foreign currency. KiCad removed the tax. A capable, fully featured EDA suite that costs nothing to install means the question shifts from “can we afford to design hardware” to “is the design any good.”
That floor is why KiCad matters to everything above it in this branch. Diode compiles Zener to .kicad_pcb rather than inventing its own layout format, because the open, free, well-documented target is the one anyone can open. The fab partners read KiCad's Gerbers without complaint. And because the suite is open source, the file formats are readable text rather than a vendor's secret — which is precisely what makes a code-defined design flow on top of it possible at all. KiCad isn't the flashy node in the tree; it's the one the others quietly depend on.
| Closed commercial EDA | KiCad |
|---|---|
| Per-seat licence, annual renewal | Free — GPLv3, no seats |
| Proprietary, opaque file formats | Readable s-expression text files |
| Scripting locked or vendor-gated | Open pcbnew Python API + IPC API |
| Forex-heavy bill before you start | Zero cost to install and ship |
| You are a customer | You can read & patch the source |
The flow is the classic two-stage EDA pipeline. You draw the circuit in Eeschema, assign each symbol a physical footprint, then move to Pcbnew to place the parts and route the copper. A 3D viewer shows the assembled board, ngspice simulates the analog behaviour, and the symbol / footprint / 3D-model libraries supply the parts. When you're done, you plot Gerbers (or IPC-2581) for the fab.
# A KiCad board is plain text: nested s-expressions. # Here's a single SMD footprint inside a .kicad_pcb file — # readable, diffable, exactly what Diode's pcb tool emits. (footprint "Resistor_SMD:R_0603_1608Metric" (layer "F.Cu") (at 128.5 96.2 90) (property "Reference" "R1") (property "Value" "10k") (pad "1" smd roundrect (at -0.825 0) (size 0.8 0.95) (layers "F.Cu" "F.Paste" "F.Mask") (net 3 "VCC")) (pad "2" smd roundrect (at 0.825 0) (size 0.8 0.95) (layers "F.Cu" "F.Paste" "F.Mask") (net 5 "GPIO0")))
The schematic (.kicad_sch) and the board (.kicad_pcb) are both stored in the same s-expression format — the Lisp-style nested-parentheses syntax shown above. That choice is load-bearing for the 2nth stack: because the format is open text rather than a binary blob, a compiler like Diode's can generate a valid board file directly, and a person can read the diff. It's exactly what Diode's pcb tool targets when it compiles a Zener design.
KiCad exposes a Python scripting API. The long-standing pcbnew bindings (generated with SWIG) let you write action plugins — scripts that appear in the PCB editor's Tools → External Plugins menu and can automate placement, generate outputs, or build custom DRC checks. As of KiCad 9 those SWIG bindings are deprecated in favour of the newer IPC API, a language-agnostic interface that's the recommended path for new add-ons going forward; the plan is to remove SWIG in KiCad 11. Either way, the point holds: KiCad is automatable, which is what lets external toolchains drive it instead of treating it as a dead end.
KiCad's longevity is the reason you can build a stack on it. It's not a one-person hobby project hanging by a thread — it's a governed open-source effort with institutional backing and a funded support layer around it.
The project is run by a technical committee of lead developers, with Wayne Stambaugh as project leader. Its single biggest inflection came when CERN — the particle-physics laboratory — began contributing seriously around 2013, funding development that turned KiCad from a capable-but-rough tool into a credible professional one. CERN's work brought the modern Pcbnew router (the push-and-shove interactive router), differential-pair routing, and a great deal of the polish that made KiCad viable for real boards.
Today the project is hosted under the Linux Foundation, which accepts tax-deductible donations on its behalf, and those donations are matched by KiCad Services Corporation — a company that also provides commercial support and in-kind sponsorship to the project. The whole suite is licensed GPLv3. Around the core sits the library ecosystem: the official schematic-symbol, footprint, and 3D-model libraries are community-contributed and maintained as separate repositories, kept independent of the application so they can move at their own pace.
Betting a hardware pipeline on a tool means betting it'll still be maintained in five years. KiCad clears that bar: institutional funding (CERN's history, the Linux Foundation's hosting), a named governance structure, a commercial support company, and a 30-plus-year track record. That stability is what lets Diode, the fabs, and your own team treat .kicad_pcb as a safe long-term target.
When an engineer writes a board in Zener and runs pcb layout, Diode emits a .kicad_pcb file and hands off to KiCad. That's where the human work happens: place the parts, route the copper with Pcbnew's interactive router, run DRC, eyeball the assembly in the 3D viewer. Diode compiles the design; KiCad is the surface you drop into for place-and-route and final refinement. Compile a Zener design, open the board in Pcbnew, finish the layout.
The boards under DroneScan's Hummingbird, Buffalo, and Meerkat units — or a ScanMan sensor node — don't need an Altium licence to exist. KiCad designs them end to end at no licence cost, which for a lean SA hardware team means the entire EDA line item is zero. Spend the budget on prototype fab runs and components instead of seat licences.
KiCad plots standard Gerber (and IPC-2581) manufacturing files and drill files that JLCPCB and PCBWay ingest directly. The board goes from Pcbnew to a fab in Shenzhen as a zip of Gerbers and a BOM — no format wrangling, no re-keying. KiCad is the last onshore step before the design crosses an ocean to get built.
KiCad is the right default for a large share of boards — but “free and capable” doesn't mean “best for everything.” Be honest about where the commercial tools still earn their licence.
.kicad_pcbFor an SA hardware team, the licence line is the one that hurts most, because it's priced in dollars or euros and it recurs every year regardless of how many boards you ship. KiCad takes that line to zero. A small Johannesburg or Cape Town team can stand up a full professional EDA flow — schematic, layout, simulation, manufacturing output — without forex exposure on a single seat. That's not a compromise tool you settle for; it's the same suite CERN funds and used for real boards.
Pair it with Diode and you get a genuinely free idea→manufacturable-board path: write the circuit in Zener, compile to .kicad_pcb, finish the layout in KiCad, plot Gerbers, send them to JLCPCB or PCBWay. The design work stays onshore — it reviews over a video call, version-controls on the GitHub the team already uses — and only the fabrication crosses a border. For a country with limited local board fabrication, that split is the practical model: keep the high-value, low-weight design work here, and ship a few kilobytes of files to where the copper gets etched.
KiCad is the floor of the hardware branch — the free, open layout surface everything else routes through. Diode compiles down to it, the commercial alternatives sit beside it, the fabs read its output, and the firmware layer lives above the board it produces.
.kicad_pcb is its output target. Zener is where you write the board; KiCad is where you finish it. This leaf is Diode's hand-off surface.Primary sources only. The project site and docs are the canonical references; the GitLab repositories hold the source and the official libraries.