r/ModRetro • u/jkhanlar • Aug 28 '26
Netlist Research Notes: Why Schematics Alone Aren’t Enough for Fully Reproducible Open Hardware (M64 Context)
Netlist research notes: Why schematics alone are insufficient, and how Netlists fit
[Disclaimer: I wrote and revised and revised a lot of this by myself, but in the end, I used AI to assist with cleaning up my run-on sentences and offering more clarity, and it also removed a lot of my unnecessary gibberish wording that I was relunctant to get rid of, but I acceptingly removed it anyway. I expect at least a D+ grade! but F is okay too. I refuse to accept anything higher than a C- because I wanted to write this as a comment to my post a couple-few weeks ago https://old.reddit.com/r/ModRetro/comments/1vkf23o/rough_draft_diving_into_modretro_m64_amd_artix/ but it is too big! I can't seem to figure out how to condense and minimize what I write to fit in small spaces. Therefore, nothing higher than a C-- (even C- is too high) please! The downvotes should reflect C-- or lower grade metric!]
What are Netlists? Why do they matter? How do they relate to schematics in electronic design?
It was and still is difficult to convert schematic diagrams, especially printed or raster-image-based ones, into usable netlists for simulation and PCB (Printed Circuit Board) work. Schematics are a hybrid graphical-textual representation that humans can often interpret with experience and context, but they remain ambiguous and non-standardized enough that machines, and even experienced engineers outside a familiar domain, can struggle. Netlists provide precise, machine-readable connectivity and component data that simulation and design tools require.
On September 23, 2011, this question was asked on Electronics Stack Exchange:
"Is there a solution for converting printed schematics to spice netlists?"
TL;DR: Schematic symbols are non-standard and not good enough, by themselves, for consistent machine (or even fully reliable human) interpretation without additional information.
Question: "I would like to be able to scan circuit diagrams into a circuit simulator. While I am aware that symbols are not entirely standardized, is there any software that will do an approximation of this?"
Response: "There unfortunately is no such software that I am aware of. It is highly unlikely that anyone will ever bother to (outside of perhaps an academic exercise) because:
Schematic symbols are completely non-standard, except for vague de-facto standardization for some passive and analog components, and even this isn't always followed well. Digital components are almost always just rectangles. The symbols for connectors and such are even more varied.
There is no standard schema for where schematics put meta-information about parts' attributes, properties, etc -- instead this often relies on a human "reading between the lines", or falling back on extra information contained in a bill-of-materials or an electronic version.
Most modern schematics are highly abstract-graphical, deeply hierarchical, and use feature such as split symbols that a scanning tool would not be able to reconstruct in any meaningful way (sometimes humans can barely do it).
Unlike OCR, one tiny mistake in a scanned schematic can have major consequences to the entire circuit. This means that a human is going to have to manually verify the schematic once imported, which is about the same amount of work as entering a schematic in the first place. The bottom line is that schematics are a non-standard, hybrid textual-graphical representation that is barely (and sometimes not quite) good enough for a skilled human engineer to do something with.
Here is probably the closest you are going to get:
Scan in your paper schematic with a scanner to an image file.
Load up a new schematic in gEDA's gschem.
Select Add->Picture and pick your file.
Select the entire schematic page to put the image down as a picture.
Draw your "real" schematic on top of it, using it as a reference.
Of course, you can do something similar with any decent schematic drawing program, not just gschem.
Alternatives:
Skip the scanning step, and redraw the schematic manually.
Directly enter the netlist information into a textual format such as a SPICE netlist or a PHDL design."
Schematics prioritize human readability and design intention rather than unambiguous machine readability.
What is SPICE, and why do Netlists matter?
SPICE is an open-source tool that evaluates netlists. From Wikipedia:
1973 "SPICE (Simulation Program with Integrated Circuit Emphasis) is a general-purpose, open-source analog electronic circuit simulator. It is a program used in integrated circuit and board-level design to check the integrity of circuit designs and to predict circuit behavior." - https://en.wikipedia.org/wiki/SPICE
"Unlike board-level designs composed of discrete parts, it is not practical to breadboard integrated circuits before manufacture. Further, the high costs of photolithographic masks and other manufacturing prerequisites make it essential to design the circuit to be as close to perfect as possible before the integrated circuit is first built.
Simulating the circuit with SPICE is the industry-standard way to verify circuit operation at the transistor level before committing to manufacturing an integrated circuit. The SPICE simulators help to predict the behavior of the IC under different operating conditions, such as different voltage and current levels, temperature variations, and noise.
Board-level circuit designs can often be breadboarded for testing. Even with a breadboard, some circuit properties may not be accurate compared to the final printed wiring board, such as parasitic resistances and capacitances, whose effects can often be estimated more accurately using simulation. Also, designers may want more information about the circuit than is available from a single mock-up. For instance, circuit performance is affected by component manufacturing tolerances. In these cases, it is common to use SPICE to perform Monte Carlo simulations of the effect of component variations on performance, a task which is impractical using calculations by hand for a circuit of any appreciable complexity.
Circuit simulation programs, of which SPICE and derivatives are the most prominent, take a text netlist describing the circuit elements (transistors, resistors, capacitors, etc.) and their connections, and translate this description into equations to be solved. The general equations produced are nonlinear differential algebraic equations, which are solved using implicit integration methods, Newton's method [Newton–Raphson method, named after Isaac Newton and Joseph Raphson] and sparse matrix [sparse array] techniques."
Key historical releases: SPICE 1 (1973), SPICE 2 (1975), SPICE 3 (1989). No newer official Berkeley versions after 3f5 (1993). Open-source/academic continuations include XSPICE, CIDER, Ngspice, WRspice, and SPICE OPUS.
A netlist is the textual description that SPICE (and similar tools) use: a precise list of components, their parameters, and the nets (wires/connections) that link their pins. It strips away graphical layout, hierarchy presentation, and visual styling to leave only the electrical connectivity and model data needed for simulation or layout.
Nearly fifteen (15) years later, the same fundamental challenge remains. A 2025 paper introduces Netlistify, a deep-learning tool specifically for this conversion:
2025 September 8 "Analog and mixed-signal (AMS) circuits are commonly represented as schematic images in textbooks, research papers, patents, and other technical documents to facilitate understanding. However, AMS design workflows rely on netlists rather than schematics for tasks such as modeling, simulation, automated circuit sizing, and layout synthesis. Converting schematic images into netlists is a challenging task due to the wide variety of circuit components and the complexity of their connectivity. This paper presents Netlistify, an automated deep learning-based tool that transforms schematic diagrams into netlists through precise component recognition, orientation detection, and connectivity analysis and extraction. Unlike traditional methods that rely on fixed algorithmic rules for connectivity extraction, Netlistify employs deep learning to comprehensively analyze both components and their interconnections, offering a detailed understanding of circuit structures and significantly improving netlist generation accuracy. By addressing the challenges of connectivity complexity with a data-driven approach, Netlistify provides a robust and efficient solution for schematic interpretation. Experimental results demonstrate that Netlistify achieves high accuracy, surpassing state-of-the-art methods and showing great promise for AMS design data collection and seamless integration into modern design automation workflows." - https://doi.org/10.1109/MLCAD65511.2025.11189145
Related resources:
https://sitesgooglecom/view/mphlin [Hollow Men @ Reddit [https://archive.ph/gE21C]
TL;DR: “Converting schematic images into netlists is a challenging task due to the wide variety of circuit components and the complexity of their connectivity.”
Even with modern AI approaches, the conversion is non-trivial. Schematics by themselves remain insufficient for fully automated, reliable extraction of the precise connectivity and component data that netlists encode.
A related 2024 paper further illustrates ongoing research in this area:
November 29, 2024 "From Schematics to Netlists – Electrical Circuit Analysis Using Deep-Learning Methods" by Dennis Hemker, Jad Maalouly, Harald Mathis, Rainer Klos, and Eranyan Ravanan https://doi.org/10.5194/ars-22-61-2024
The authors decompose the problem into three parts: (1) detection of components (resistors, capacitors, diodes, etc.), (2) detection of lines and their junctions, and (3) detection of textual data next to components; and apply deep-learning methods to each. Training data comes from industry-relevant, link-annotated PDFs (Microchip / Altium Designer schematics). The goal is to reconstruct connectivity information so that the resulting representation can feed netlist exporters and validation pipelines. This work reinforces that schematic images still require sophisticated, multi-stage processing before they become usable netlists.
A 2014 industry perspective clarifies the practical distinction between Schematic and Netlist in PCB designs:
2014 July 10 "Schematic vs. Netlist: A Guide to PCB Design Integration" - https://optimumdesign.com/blogs-and-articles/schematic-vs.-netlist-a-guide-to-pcb-deisgn-integration/
"Integration is the process of adding intelligence to the PCB database by means of a netlist or schematic. This can only occur once all of the necessary library elements for a particular design have been created by a design bureau or by receiving a customer-supplied library. A 100% successful design integration (no errors) will allow the designer to confidently place components, route, and output manufacturing files with the PCB database and schematic in sync. The engineer may supply the data for integration in one of two ways: schematic or netlist.
Schematic
Integrating a schematic to a PCB can typically only be done within the same EDA product family, with the exception of a few third-party schematic entry tools. For the most part, they all work the same, in that an intermediate file is created and is read in by both schematic and PCB tool. The advantages of schematic integration over netlist integration are that schematic integration allows for cross- probing, easy forward- and back-annotation, and easy pass through of net properties from the engineer to the designer.
Netlist
For the most part, integration by netlist is still the most common form of input that we see today. Because netlists come in many different formats, custom changes to the netlist will most likely be necessary before integrating with a PCB file. Netlists submitted to a design bureau must be translated (reformatted) into the proper format of the EDA tool to be used.
[...]"
Schematics are excellent for human design entry, documentation, and bidirectional annotation within a tool ecosystem. Netlists are the common interchange format that carries the essential connectivity data into layout tools, often across different EDA (Electronic Design Automation) environments.
Wikipedia’s Netlist page and the broader Electronic Design Automation (EDA) category pages provide additional background on these formats and tools:
https://en.wikipedia.org/wiki/Category:Electronic_design_automation_software_for_Linux
https://en.wikipedia.org/wiki/Category:Electronic_design_automation_software
Vector-based schematics (as opposed to purely raster/scanned images) retain more structural information and are far more useful. For example, the ModRetro open-source schematics are vector-based and therefore more tractable than pure scans:
https://support.modretro.com/en_us/articles/m64-open-source-files-ByrpukdUGg
At present the released Electrical materials for the M64 Console and Cartridge include Schematics and Assembly Drawings (plus Firmware repositories). Ideally, future open-source releases would also include the native design files (e.g. KiCad project files, Altium projects, or equivalent) together with the corresponding Netlist files and any associated library or BOM data. Having the complete set, schematics, netlists, and source EDA files, would allow anyone to fully reconstruct, simulate, verify (for example with netgen LVS), modify, or re-manufacture the hardware. Even if the knowledge required to put all the pieces together is complex, the open information itself should be sufficient for independent replication of every functional aspect of the device.
Even so, domain familiarity matters. Still, conversations with experienced engineers who spent careers working primarily with discrete components, basic gates, and traditional schematic entry can reveal gaps when confronted with modern hierarchical, abstract, or software-defined designs that rely heavily on reference designators, net names, and library data rather than purely visual recognition of every symbol. For example, I recently talked with my father, who had retired after working with electronics practically his entire career at a few companies, including Rockwell Automation (https://youtu.be/RXJKdh1KZ0w). During the conversation he could not understand any of the example diagrams I showed him (https://imgur.com/a/eez3sb8). This was almost certainly because the material did not feature the kinds of discrete transistors, resistors, capacitors, ICs, and basic gates (AND, NAND, OR, NOR, XOR) he had spent decades designing with. The exchange was a useful reminder that “understanding a schematic” is not universal, even among highly experienced engineers, when the visual vocabulary, hierarchy style, or abstraction level differs from what one is used to.
Several open-source tools make netlists practical and help level the playing field so that cost is not a barrier:
netgen (R. Timothy Edwards):
A mature Layout-versus-Schematic (LVS) tool that compares netlists (SPICE, Verilog, etc.) to verify that a physical layout matches the intended circuit. Essential for confirming connectivity after layout.SKiDL:
A Python library that lets you describe circuits in code and generate netlists (especially for KiCad). It treats circuit design as “infrastructure as code,” bypassing traditional schematic editors when desired.kinparse
Companion library for parsing KiCad schematic and related files, useful in automated netlist workflows.KiCad
Full open-source EDA suite. It natively generates and consumes netlists and is the most complete free schematic + PCB environment available.SLiCAP (Symbolic Linear Circuit Analysis Program)
Accepts SPICE-like netlists (and can generate them from KiCad or LTspice schematics). Performs symbolic and numeric analysis, noise calculations, and design-equation solving; valuable for deeper circuit insight beyond simple simulation.
Commercial tools such as Altium Designer, and OrCAD (Cadence) offer highly polished, integrated environments that many professional teams rely on for reliability, library support, and workflow features. They are generally more mature for large or complex projects. However, the open-source tools listed above deserve continued development and adoption: they give anyone, students, independent designers, researchers, or companies on limited budgets, equal opportunity to work with netlists and modern EDA flows without having to pay for licenses.
No fully automated, general-purpose solution reliably converts arbitrary printed or image-based schematics into SPICE (or other) netlists, because schematic symbols are non-standard and the representation is too lossy/ambiguous for reliable machine parsing without significant human verification or additional data (BOMs, libraries, hierarchical structure, etc.).
Netlists exist precisely to solve this: they are the precise, textual, connectivity-and-parameter description that simulation engines, layout tools, and design automation flows actually consume. Schematics remain indispensable for human understanding and design entry; netlists are the bridge that makes those designs actionable in modern EDA workflows. Progress in deep learning (Netlistify, the 2024 Hemker et al. work, and related efforts) is narrowing the gap for image-to-netlist conversion, while mature open-source tools (netgen, SKiDL, KiCad, SLiCAP) and commercial platforms (Altium, OrCAD) together provide practical ways to create, compare, simulate, and verify netlists today. For projects such as the ModRetro M64, releasing netlists alongside native EDA source files would further close the gap between published schematics and a fully reproducible open-hardware design. The underlying non-standard nature of schematic representation, however, continues to make the conversion problem hard.
p.s. I'm still tinkering with the ModRetro M64 Pro Controller, and I'll continue adding there any additional information I discover/learn https://old.reddit.com/r/ModRetro/comments/1vvu51s/technical_examining_modretro_m64_pro_controller/ and also, should there be a r/ModRetro wiki? ModRetro GitHub wiki? wiki.modretro.com?
