Turning a Schematic Image into a SPICE Netlist

Search for a way to turn a schematic image into a SPICE netlist and you will find research papers and GitHub repositories, not tools. That is not an accident — the problem is genuinely hard, and it only became tractable recently.

This article explains what the hard parts are, what the published work achieves, and what you can actually use today.

Why it is harder than it sounds

Reading a schematic is not one problem, it is four, and each can fail independently.

Finding the components. A resistor is a zigzag or a rectangle depending on the standard the author used. A capacitor is two parallel lines, sometimes one of them curved. Hand-drawn symbols vary more than printed ones, and a photograph adds skew, shadow and blur on top.

Working out what is connected to what. This is the step that decides whether the netlist is right. Two crossing lines might be a junction or might not — the convention is a dot, and plenty of schematics omit it. A wire that passes behind a component body has to be understood as continuous. Get one junction wrong and the circuit you simulate is not the circuit in the picture.

Reading the labels and pairing them up. R1 and 1k are two separate pieces of text that belong to one component, and which text belongs to which part is a spatial judgement, not an OCR result.

Writing a netlist that actually runs. Every node needs a name, every component needs its pins in the right order, and the whole thing needs a ground reference. A netlist that is 95% correct does not run 95% of the time — it fails.

What the research achieves

The 2026 literature is worth knowing about, because it tells you what is realistic.

SINA describes a four-stage pipeline: component detection, connectivity inference, reference-designator extraction, then netlist generation. It uses a YOLOv11 object detector for components, and reports an F1 score of 96.47% on detection. For the netlist itself it feeds three things to a vision-language model — the OCR'd designators, the connectivity map, and the original image for context. Against Masala-CHAI, an earlier open framework, it reports 2.72× the overall accuracy.

AnalogMaster takes a similar route with a large language model identifying components and their interconnections, aimed at analog IC design all the way to layout.

On the open-source side, Circuit Schematic Image Interpreter is a Python package that interprets schematic images and emits a netlist you can open in LTspice, and netlist-viewer solves the reverse problem, drawing a schematic from a netlist.

Two things stand out in that list. The first is that detection is largely solved — a 96% F1 on components is good enough. The second is that everyone puts a language model in the final stage, because turning a component-and-connection graph into a valid netlist is a language problem as much as a vision one.

What is missing from all of it

None of it is a product. They are papers with code, which means cloning a repository, installing dependencies, obtaining model weights, and debugging someone's research environment before you can test one photograph of one schematic. That is a reasonable price for a researcher and an unreasonable one for a student with a homework deadline.

Doing it in a browser

CircuPilot runs this pipeline as a hosted feature. Photograph a schematic — from a textbook, a whiteboard, a lecture slide — and it returns an editable schematic, a SPICE netlist, and a simulation you can run.

The part worth explaining is what happens after the image is read, because it is where most of the reliability comes from. The model's output does not go straight to SPICE. It goes into a checked intermediate representation first, and that representation is validated before anything is simulated:

every node is reachable, so there are no floating pins
a ground reference exists, or one is inferred
no source is shorted
component ids are unique and pin order matches the component type
every model or subcircuit the netlist references is actually defined

Only then is the netlist generated and handed to real ngspice. That closure check is the difference between "the AI produced something netlist-shaped" and "this netlist runs", and it is the reason the same validation rules are also written into the prompt — so the model satisfies them on the first attempt rather than being corrected afterwards.

You can copy the resulting netlist out and open it in LTspice or ngspice locally. It is standard SPICE, not a private format.

What to expect, honestly

It works well on clean printed schematics of moderate size. It is less reliable on:

Dense schematics with many crossing wires, which is exactly where connectivity inference is hardest
Hand-drawn circuits with unconventional symbols
Poor photographs — heavy skew, shadow across the page, low resolution
Unusual parts, where a component may be read as the nearest familiar symbol

The practical habit is the same one the research implies: read the schematic it gives you back before you trust the simulation. It is editable for exactly that reason, and fixing one misread component on the canvas takes a few seconds, against redrawing the whole circuit by hand.

Try it

No signup is needed to try it, and the netlist is yours to copy.

Open the simulator →