Skip to main content

Circuitscript vs SKiDL

If you are evaluating code-based schematic tools, you have probably already found SKiDL. It is the closest thing to Circuitscript in terms of scope: both tools let you describe a circuit in code and export a KiCad netlist, and neither does PCB layout itself. Both are MIT-licensed and run fully local. The differences are in approach, and whether they matter depends on what you need from the tool.

What SKiDL does well​

SKiDL has been around since 2016 and is actively maintained (latest release v2.2.3, April 2026). It has been used in real designs, documented on forums, and covered by Hackaday and Adafruit. Because SKiDL is a Python library, it integrates natively with the entire Python ecosystem. You can pull in pandas to process a BOM, use numpy for filter calculations, compute part values algorithmically, or wire it into a CI pipeline using standard Python tooling. No adapter needed; it is just Python.

SKiDL also works directly with KiCad's component libraries (versions 5 through 9). Part lookup uses KiCad library references ("Device", "R", "LED"), which means you are working with the same part definitions your PCB layout will use. The companion Zyc GUI helps search parts and assign footprints. For teams already deep in the KiCad tooling, there is nothing to translate. Circuitscript can reach the same catalog (the circuitscript/kicad-libraries project ports the KiCad symbol libraries into Circuitscript), but SKiDL's access is more direct and comes with the Zyc footprint-assignment tooling.

Two SKiDL capabilities stand out:

  • SPICE simulation. SKiDL is built on top of PySpice, so you can describe a circuit and run an ngspice simulation directly from Python. Circuitscript currently does not support SPICE simulations, but this feature is included in the roadmap.
  • Extensible ERC. Both tools do electrical rule checking, but they differ in shape. SKiDL ships built-in checks and lets you add your own via erc_assert(), so validation is open-ended. Circuitscript's ERC is a fixed set of 22 rules with per-rule severity, so it is more turnkey but not user-extensible.

The same circuit in both languages​

A 3.3 V supply through a 100 Ω resistor to a green LED, connected to ground. This is a trivial circuit, but it shows how each tool approaches connectivity.

SKiDL (Python):

from skidl import *

vcc = Net("VCC")
gnd = Net("GND")

r1 = Part("Device", "R", footprint="Resistor_SMD:R_0402_1005Metric")
r1.value = "100"
led1 = Part("Device", "LED", footprint="LED_SMD:LED_0805_2012Metric")

vcc & r1 & led1 & gnd

generate_netlist()

Circuitscript:

from "std" import *

v3v3 = supply("3V3")
gnd = dgnd()

at v3v3
wire down 100 right 100
add res(100)
wire right 100 down 100
add led("green") pin 2 # anode
wire down 100
to gnd
line 6:13V3Component R1: line 8:1R1100Component D1: line 10:112D1greenline 12:4GND

Both produce a netlist. The SKiDL version looks like Python with circuit concepts grafted on: you instantiate Part objects and assign Net objects. To wire them in series you chain them with &. But & is Python's bitwise-and operator, overloaded by SKiDL, so nothing in the line signals that it means "connect," or what ends up joined to what.

The Circuitscript version reads more like a description of the circuit itself. at v3v3 puts you at the supply. wire moves the cursor. add res(100) places a resistor. to gnd closes the connection. The concepts (cursor position, net membership, component placement) are language primitives rather than library objects.

What Circuitscript does differently​

Purpose-built language, not a library​

Circuitscript was designed from the start as a language for describing circuits. Net, wire, cursor, pin: these are not objects you import; they are how the language works. The creator of SKiDL has noted publicly that previous circuit DSL attempts failed by inventing new languages without an existing user base. Circuitscript takes a different approach: a Python-like syntax built around circuits that stays readable and easy to follow.

Designer-controlled schematic layout​

This is the most concrete difference, and it is more subtle than "one draws pictures and the other doesn't." SKiDL can generate visual schematics: it emits SVG (via netlistsvg or KiCad symbol graphics) and .kicad_sch files. But the arrangement is machine-decided. You do not choose where symbols sit; an auto-layout algorithm does. The picture is a rendering of the netlist and not something you authored.

In Circuitscript, the source is the layout. The wire and at commands describe spatial arrangement as well as connectivity: at sets a cursor position, wire moves it, add places a component. The SVG and PDF reflect how you described the circuit, not what an autorouter decided, which is what keeps the output readable rather than auto-routed chaos:

circuitscript input.cst output.svg
circuitscript input.cst output.net
circuitscript input.cst output.kicad_sch

Same .cst file, three outputs. The schematic you hand to a reviewer and the netlist you hand to pcbnew are always in sync, and the schematic reads the way you laid it out. The .kicad_sch export preserves your symbol positions, so the SVG, the PDF, and the schematic you open in KiCad all show the same layout you authored. SKiDL's .kicad_sch comes back auto-placed instead. If your workflow depends on a readable, deliberately arranged schematic for documentation, teaching, or review, that authored control is the difference. If you just need a picture and don't care how it is arranged, SKiDL's auto-generated output may be enough.

Circuitscript also supports multi-page sheets, frames, and title blocks for printable, shareable PDF documentation. SKiDL has no documented equivalent; its visual output is auto-generated graphics, not a paginated document.

BOM output with part mapping​

Circuitscript emits a CSV bill of materials and can map parts to supplier part numbers, so the BOM comes out ready to order rather than needing a manual MPN pass afterward. SKiDL generates an XML netlist you can turn into a BOM, but it does not document supplier part mapping, so that step is on you.

Buses​

Circuitscript supports buses. Wide multi-signal connections do not have to be wired one net at a time and can be routed as a group. Both tools can express a bus compactly; SKiDL does it through Python objects, Circuitscript through language syntax.

Online editor​

bench.circuitscript.net runs Circuitscript in the browser. Write a circuit, watch the schematic render live, then export an SVG image or KiCad netlist to import into KiCad pcbnew. No installation is required for evaluation.

Key differences at a glance​

SKiDLCircuitscript
LanguagePython libraryPurpose-built DSL
Graphical outputYes, auto-laid-out (SVG)Yes, designer-controlled (SVG, PDF)
Layout control in sourceNoYes (cursor model)
Multi-page sheets / title blocksNoYes
KiCad netlist exportYesYes
KiCad schematic (.kicad_sch)Yes (auto-laid-out)Yes (layout preserved)
KiCad component librariesYes (native, v5–9)Yes (ported library)
CSV BOM with supplier mappingNo (XML netlist → BOM)Yes
SPICE simulationYes (PySpice/ngspice)No
Bus / multi-signal abstractionYes (Bus)Yes
ERCBuilt-in + extensible (erc_assert)Built-in 22-rule, severity-tunable
Online editorNoYes (Bench)
MaturitySince 2016Since 2025
Community sizeLargerSmaller
Python ecosystem integrationNativeNo

When SKiDL is the better fit​

  • You are already in a Python-heavy workflow and want to generate circuits from scripts, notebooks, or data pipelines
  • You need to pull part values from an external source (a spreadsheet, a database) and compute them in Python before generating the netlist
  • You want to run SPICE simulations on your design without leaving the tool
  • You want a tool with a longer track record and more community examples to draw from
  • Your team is already using KiCad's component library and wants direct integration

When Circuitscript is the better fit​

  • You need a deliberately laid-out schematic alongside the netlist (not an auto-arranged rendering) for documentation, code review, or sharing with someone who is not running the toolchain
  • You need multi-page sheets, frames, and title blocks for printable, professional documentation
  • You prefer a syntax built around circuit concepts rather than Python objects, and want SVG/PDF output without needing KiCad installed to visualize it
  • You want a CSV BOM with supplier part numbers ready to order, without a separate part-mapping step
  • You want to evaluate the tool in a browser before committing to an install
  • You are writing circuits that benefit from a readable, spatial description rather than a node-connection graph

Both end up in the same place​

SKiDL and Circuitscript both produce KiCad netlists that can be imported into pcbnew for PCB layout. The fabrication workflow downstream is identical. The choice is about the authoring experience and what else you need from the tool: Python integration, SPICE simulation, and community depth (SKiDL), or designer-controlled schematic layout and circuit-native syntax (Circuitscript).

If your current pain point is that you want a schematic that diffs cleanly in git and produces both a deliberately arranged SVG and a KiCad netlist from one source file, Circuitscript does exactly that. If you are already scripting in Python, want to simulate your circuits, or want to generate netlists programmatically without learning a new language, SKiDL is probably the right answer.

Try Circuitscript in the browser at bench.circuitscript.net, or install the CLI:

npm install -g circuitscript