Technical Summary: SchGen - PCB Schematic Generation with Semantic-Grounded Code Representations

Problem Statement

Printed Circuit Board (PCB) schematic design is a foundational step in electronic hardware development, yet it remains a manual, expertise-intensive process reliant on Electronic Design Automation (EDA) tools. While generative AI has made strides in digital and analog Integrated Circuit (IC) design, the generation of PCB schematics from natural-language intent remains largely unexplored.

The primary challenges hindering progress in this domain are:

1. Representation Mismatch: Existing schematic formats (e.g., raw KiCad files) are dominated by verbose, tool-specific metadata and geometry-heavy descriptions. These formats are difficult for Large Language Models (LLMs) to parse reliably, leading to formatting errors and unusable outputs. Conversely, image-based representations are not directly editable or machine-readable.
2. Data Scarcity: Although open-source hardware designs are available, they exist in heterogeneous formats, often as static images for human viewing rather than editable source files, making them difficult to reuse for training large-scale datasets.
3. Complexity of the Task: Unlike digital logic (Boolean) or analog ICs (topology-driven), PCB schematics involve diverse components (digital/analog ICs, passives, connectors) and complex wiring driven by high-level functional requirements in natural language.

Methodology

1. Semantic-Grounded Code Representation

To address the representation bottleneck, the authors introduce a novel semantic-grounded code representation that transforms schematic generation from an absolute-geometry prediction problem into a semantics-driven matching task. This representation abstracts the schematic design process into a series of structured editing operations using a custom Python API:

• Editing Primitives: The API includes functions such as add_schematic_symbol, add_label, get_pin_location, and connect_pins.
• Relative Placement: Instead of absolute coordinates, the system uses local coordinate systems with relative offsets from anchor components. This reduces the spatial reasoning burden on LLMs.
• Pin-Name-Based Wiring: Connections are defined by semantic pin names (e.g., VCC, TXD, GPIO1) rather than absolute wire coordinates. This aligns with how human engineers reason about circuit connectivity.
• Output: Executing this code generates a valid, editable KiCad schematic file.

2. Human-Agent Collaborative Data Pipeline

To overcome data scarcity, the authors constructed a large-scale dataset of 1,390 unique schematic designs (expanded to 8,420 samples via data augmentation) using a pipeline that converts open-source hardware designs (from SparkFun) into the proposed code representation:

• Agentic Sketch: Multi-modal LLMs (e.g., GPT-5) generate initial Python code drafts from schematic images. The system iterates based on execution feedback (syntax errors, illegal symbols) to produce a "sketch" version.
• Human Alignment: Human engineers review and correct the sketches to ensure alignment with the original reference designs, fixing complex wire connections that LLMs struggle with.
• Schematic-to-Code Conversion: A parser converts the aligned KiCad files back into the structured code representation, ensuring the dataset consists of executable, error-free code.
• Prompt Synthesis: User requests are synthesized using multi-modal LLMs to create diverse prompts (concise and detailed) paired with the code.

3. Model Training

The authors fine-tuned GPT-oss-20b (a 20-billion parameter model) to create SchGen.

• Supervised Fine-Tuning (SFT): The model is trained on the paired dataset of user prompts and schematic code.
• Chain-of-Thought (CoT): The dataset is augmented with distilled reasoning steps generated by larger models (GPT-oss-120B) to enhance the model's ability to plan the schematic generation process.

Key Contributions

1. New Task Definition: The paper defines the task of generating editable PCB schematics from natural language prompts, a domain previously unexplored by generative AI.
2. SchGen Model: The introduction of SchGen, the first LLM capable of generating editable PCB schematics directly from user requests.
3. Semantic-Grounded Representation: A novel code representation that abstracts schematic design into relative placement and pin-name connectivity, significantly improving learnability and generation quality compared to raw file formats.
4. Large-Scale Dataset: The construction of a high-quality dataset of 1,390 unique schematic types paired with user prompts, created via a scalable human-agent collaborative pipeline.

Experimental Results

The authors evaluated SchGen against ablation variants (different representations), raw KiCad file baselines, and frontier general-purpose LLMs (GPT-5.2, GPT-o4mini, Grok-4).

• Representation Efficacy: The proposed Code-L1 representation (with relative coordinates and pin-name connectivity) achieved an 82.00% valid circuit rate and 60.5% expert-verified functional correctness. This significantly outperformed:
  • Code-L2 (without relative coordinates): 78.16% valid, 33.0% functional correctness.
  • Code-L3 (without pin-name connectivity): 76.40% valid, 6.0% functional correctness.
  • Raw KiCad Files: Only 32.45% valid circuits and 3.0% functional correctness.
• Comparison with Frontier Models: Despite having only 20B parameters, SchGen outperformed larger models (including GPT-5.2) across all metrics when using the same representation. For instance, SchGen achieved 60.5% functional correctness compared to 50.0% for GPT-5.2 (using the same Code-L1 representation).
• Generalization: On an unseen out-of-distribution test set from GitHub projects, SchGen maintained high performance, matching the netlist accuracy of GPT-5.2 (40.65% vs. 40.64% Jaccard similarity), demonstrating the model's ability to generalize learned design logic.

Significance and Claims

The paper claims that representation design is the critical enabler for applying generative models to complex hardware design tasks. The results highlight that:

• Transforming geometry-driven generation into a semantics-driven matching task allows LLMs to effectively capture both spatial reasoning and functional intent.
• A well-structured, domain-specific representation can allow a smaller, fine-tuned model to outperform much larger, general-purpose frontier models.
• The proposed pipeline demonstrates a viable path for automating the schematic design stage, which has historically been the least automated part of the PCB workflow.

The authors note limitations, including the current focus on structured schematics from specific sources (SparkFun) and the lack of modeling for advanced PCB constraints (e.g., high-speed routing, EMI). They emphasize that human involvement remains necessary to ensure the robustness and safety of generated schematics, positioning SchGen as a foundational step toward broader automation in electronic design rather than a fully autonomous solution.