AnalogCoder: Analog Circuit Design via Training-Free Code Generation

Yao LaiSungyoung LeeGuojin ChenSouradip PoddarMengkang HuDavid Z. PanPing Luo

article2025AAAI161 citations

Presents AnalogCoder, the first training-free LLM-based agent for analog integrated circuit design that generates executable PySpice Python code, uses automated feedback-driven error correction, and archives reusable sub-circuits to outperform standard GPT-4o on a new 24-circuit benchmark.

Listen

Analog circuit design is a vital component of modern semiconductor technology, enabling electronic devices to interface with physical signals such as sound, light, and temperature. Despite recent breakthroughs using Large Language Models to automate digital chip design, analog design has remained heavily reliant on scarce human expertise. This lag stems from the high complexity of analog components, the need for precise physical-level representations rather than high-level abstractions, and a severe scarcity of analog circuit code in public training data. As a result, manually designing analog circuit netlists remains a slow, labor-intensive, and error-prone bottleneck in chip development.

The article introduces and evaluates AnalogCoder, the first training-free Large Language Model agent developed specifically for automated analog integrated circuit design. The main objective is to demonstrate that an artificial intelligence agent can successfully generate functional analog circuits from natural language requirements by framing circuit design as executable Python code generation.

To bridge the data and domain gap, the approach relies on Python and the PySpice library, bypassing the poorly represented specialized circuit syntax (such as standard SPICE netlists) in favor of a programming language in which models exhibit deep fluency. The framework incorporates domain-specific prompt engineering, including step-by-step reasoning and one-shot examples, alongside a four-stage automated feedback flow that evaluates requirement adherence, operating point stability, DC signal sweeps, and functional circuit performance over up to three iterative repair attempts. Furthermore, successful circuits are archived into a reusable modular tool library that can be queried and retrieved to construct complex, multi-stage composite designs. The authors evaluated this system across a newly constructed benchmark comprising 24 diverse analog design tasks ranging from basic amplifiers to composite oscillators and operational amplifier systems, comparing multiple commercial and open-source models.

AnalogCoder achieved the highest overall success rate, autonomously solving 20 out of 24 benchmark circuit challenges and attaining an average first-attempt success rate (Pass@1) of 66.1%. By comparison, standard GPT-4o without the modular tool library solved 15 tasks with a 54.2% Pass@1 rate, while top open-source models such as DeepSeek-V2 and Llama-3-70B solved 13 and 11 tasks, respectively. The tool library proved essential for complex composite architectures: standard models failed on composite tasks like integrators, differentiators, and adders, whereas AnalogCoder designed them with high reliability by reusing previously verified sub-circuits. Ablation studies demonstrated that generating Python instead of native SPICE, applying automated error feedback, and providing structured reasoning prompts each provided substantial performance improvements, with fine-tuning offering minor syntax consistency but limited gains on complex tasks.

These findings indicate that generative AI can dramatically lower technical barriers and compress development timelines in analog chip design. By enabling automated netlist synthesis without specialized model retraining, organizations can reduce engineering labor costs, accelerate time-to-market, and allow non-specialist engineers to prototype functional analog blocks. Crucially, modular reuse and closed-loop simulation feedback mitigate the risk of common design flaws, such as disconnected nodes and inactive transistors.

Organizations exploring automated circuit synthesis should consider deploying closed-loop code generation pipelines that leverage high-level languages and modular sub-circuit registries rather than attempting direct hardware description generation from scratch. For immediate applications, decision-makers should pair functional generative agents with established downstream optimization tools for fine-grained parameter tuning. Further research is recommended to expand sub-circuit libraries and evaluate the framework on larger, production-grade mixed-signal systems.

Confidence in these findings is supported by standardized multi-trial simulation benchmarks across numerous leading foundation models. However, readers should note that the current scope focuses strictly on functional circuit topology creation rather than deep transistor sizing and layout optimization. Additionally, four of the most complex benchmark circuits (including phase-locked loops and voltage-controlled oscillators) were not solved by any evaluated model, indicating clear operational boundaries where full automation is not yet mature.

Cover for AnalogCoder: Analog Circuit Design via Training-Free Code Generation

Abstract

Analog circuit design is a significant task in modern chip technology, focusing on the selection of component types, connectivity, and parameters to ensure proper circuit functionality. Despite advances made by Large Language Models (LLMs) in digital circuit design, the complexity and scarcity of data in analog circuitry pose significant challenges. To mitigate these issues, we introduce AnalogCoder, the first training-free LLM agent for designing analog circuits through Python code generation. Firstly, AnalogCoder incorporates a feedback-enhanced flow with tailored domain-specific prompts, enabling the automated and self-correcting design of analog circuits with a high success rate. Secondly, it proposes a circuit tool library to archive successful designs as reusable modular sub-circuits, simplifying composite circuit creation. Thirdly, extensive experiments on a benchmark designed to cover a wide range of analog circuit tasks show that AnalogCoder outperforms other LLM-based methods. It has successfully designed 20 circuits, 5 more than standard GPT-4o. We believe AnalogCoder can significantly improve the labor-intensive chip design process, enabling non-experts to design analog circuits efficiently.

Table of Contents

  • Introduction
  • Preliminary
  • Our Approach
  • Experiments
  • Conclusion
  • Acknowledgments
  • References

Knowls

  1. Knowl 1 — AnalogCoder Framework for Training-Free Analog Circuit Design

    model/method

    AnalogCoder is an LLM-based agent designed to automate analog integrated circuit design without model retraining. Rather than generating low-level SPICE netlists directly—which suffer from severe data scarcity in public LLM pretraining corpora—AnalogCoder reformulates circuit synthesis as executable Python code generation using the PySpice library.

    The framework incorporates three primary prompt engineering strategies:

    1. Target Language Selection: Generates Python scripts utilizing PySpice, leveraging LLMs' strong Python coding capabilities.
    2. In-Context Learning (ICL): Provides a one-shot example of a two-stage amplifier with active and resistive loads to standardize netlist structure, component instantiation, and node naming conventions.
    3. Chain-of-Thought (CoT) Prompting: Prompts the LLM to outline an explicit design plan—including component selection and interconnection topology—prior to generating the executable code.
  2. Knowl 2 — Feedback-Enhanced Circuit Design and Self-Repair Flow

    algorithm

    AnalogCoder employs a four-stage verification and feedback loop allowing the LLM agent up to three iterative attempts to fix syntax, operational, and functional errors in the generated analog circuit code:

    Input: Natural language circuit design task T, Maximum attempts N_max = 3
    Output: Verified PySpice circuit code C or Failure
    Initialize attempt count k = 1
    Generate initial circuit code C from task T using prompt with ICL and CoT
    while k <= N_max do
        // Stage 1: Requirement Check
        if input/output nodes or essential components are missing in C then
            feedback = generate_requirement_error_message(C)
            C = regenerate_code(T, C, feedback)
            k = k + 1
            continue
        end if
        // Stage 2: Simulation and Operating Point Check
        run_status, op_results = execute_op_simulation(C)
        if run_status == FAILED or any MOSFET has (Vgs <= Vth or Vds <= Vgs - Vth) then
            feedback = generate_op_error_message(op_results)
            C = regenerate_code(T, C, feedback)
            k = k + 1
            continue
        end if
        // Stage 3: DC Sweep Check
        sweep_results = execute_dc_sweep(C)
        if output does not vary with input or optimal bias is invalid then
            feedback = generate_dc_sweep_error_message(sweep_results)
            C = regenerate_code(T, C, feedback)
            k = k + 1
            continue
        end if
        // Stage 4: Function Check
        func_results = execute_function_simulation(C) // AC, DC, or transient
        if circuit specifications (e.g., gain, CMRR, oscillation periodicity) fail then
            feedback = generate_function_error_message(func_results)
            C = regenerate_code(T, C, feedback)
            k = k + 1
            continue
        end if
        return C // Passed all checks
    end while
    return Failure
  3. Knowl 3 — Modular Circuit Tool Library for Composite Circuit Synthesis

    model/method

    To design complex analog circuits, AnalogCoder utilizes a Circuit Tool Library that archives verified basic circuits as reusable subcircuits. The mechanism operates in two phases:

    1. Library Archival (Tool Addition): When a basic circuit (such as a single-stage amplifier, operational amplifier, or current mirror) is successfully synthesized and passes all verification checks, its implementation code, calling interface (e.g., circuit.subcircuit(...) and subcircuit instantiation circuit.X(...)), and post-simulation performance specifications (e.g., gain AvA_v, phase difference) are stored. Task descriptions and specifications act as query keys, while Python code and invocation signatures serve as values. When multiple implementations exist for a task, the candidate maximizing key specifications (e.g., highest gain) is retained.

    2. Subcircuit Retrieval (Composite Generation): When presented with a composite circuit task (e.g., an op-amp integrator, differentiator, or adder), the LLM agent queries the library for requisite functional blocks. The retrieved subcircuit code and calling syntax are injected into the context prompt, allowing the agent to instantiate pre-verified submodules directly.

  4. Knowl 4 — Analog Circuit Design Benchmark Suite

    experimental setup

    The evaluation benchmark consists of 24 analog circuit design tasks divided into basic circuits (Tasks 1–15) and composite circuits (Tasks 16–24), categorized into easy, medium, and hard difficulty levels based on component count and interconnection complexity:

    • Task 1 (Easy): Common-source amplifier with resistive load
    • Task 2 (Medium): 3-stage common-source amplifier with resistive loads
    • Task 3 (Medium): Common-drain amplifier with resistive load
    • Task 4 (Medium): Common-gate amplifier with resistive load
    • Task 5 (Medium): Cascode amplifier with resistive load
    • Task 6 (Easy): NMOS inverter with resistive load
    • Task 7 (Easy): Logical CMOS inverter with NMOS and PMOS
    • Task 8 (Easy): NMOS constant current source with resistive load
    • Task 9 (Medium): Common-source amplifier with diode-connected load
    • Task 10 (Medium): 2-stage amplifier with Miller compensation capacitor
    • Task 11 (Hard): Operational amplifier with active current mirror loads
    • Task 12 (Hard): Cascode current mirror
    • Task 13 (Hard): Common-source operational amplifier with resistive loads
    • Task 14 (Hard): 2-stage operational amplifier with active loads
    • Task 15 (Hard): Cascode operational amplifier with cascode loads
    • Task 16 (Hard): RC phase-shift oscillator
    • Task 17 (Hard): Wien Bridge oscillator
    • Task 18 (Hard): Op-amp integrator
    • Task 19 (Hard): Op-amp differentiator
    • Task 20 (Hard): Op-amp adder
    • Task 21 (Hard): Op-amp subtractor
    • Task 22 (Hard): Non-inverting Schmitt trigger
    • Task 23 (Hard): Voltage-Controlled Oscillator (VCO)
    • Task 24 (Hard): Phase-Locked Loop (PLL)
  5. Knowl 5 — Pass@k Metric for Analog Circuit Generation

    equation

    To evaluate code generation correctness across multiple stochastic model outputs, the unbiased Pass@k\text{Pass@}k metric is defined as:

    Pass@k=1−(n−ck)(nk)\text{Pass@}k = 1 - \frac{\binom{n-c}{k}}{\binom{n}{k}}

    where:

    • nn is the total number of independent generation trials per task (n≥kn \ge k). In experiments, n=30n = 30 for open-source LLMs and baseline GPT-3.5, and n=15n = 15 for GPT-4, GPT-4o, and fine-tuned GPT-3.5.
    • cc is the number of trials that pass all four verification stages (requirement, simulation/operating point, DC sweep, and functional verification).
    • kk is the evaluation budget (k∈{1,5}k \in \{1, 5\}).

    A design task is counted in '# Solved' if c≥1c \ge 1 within the nn trials.

  6. Knowl 6 — Comparative Performance of LLMs on the Analog Circuit Benchmark

    data/table

    The performance of various LLMs and the AnalogCoder framework across the 24 analog design tasks is summarized below. All models utilize prompt engineering and feedback flow, while AnalogCoder additionally incorporates the circuit tool library for composite tasks:

    Model CodeLlama-70B WizardCoder-33B DeepSeek-V2 Llama3-70B GPT-3.5 GPT-4o (w/o tool) AnalogCoder
    Metric Pass@1 Pass@5 Pass@1 Pass@5 Pass@1 Pass@5 Pass@1 Pass@5 Pass@1 Pass@5 Pass@1 Pass@5 Pass@1 Pass@5
    Task 1 20.0 70.2 93.3 100.0 100.0 100.0 93.3 100.0 86.7 100.0 100.0 100.0 100.0 100.0
    Task 2 3.3 16.7 13.3 53.8 93.3 100.0 20.0 70.2 70.0 99.9 100.0 100.0 100.0 100.0
    Task 3 0.0 0.0 0.0 0.0 83.3 100.0 90.0 100.0 3.3 16.7 100.0 100.0 100.0 100.0
    Task 4 3.3 16.7 10.0 43.3 70.0 99.9 83.3 100.0 50.0 97.9 100.0 100.0 100.0 100.0
    Task 5 3.3 16.7 13.3 53.8 76.7 100.0 20.0 70.2 10.0 43.3 100.0 100.0 100.0 100.0
    Task 6 23.3 76.4 13.3 53.8 100.0 100.0 100.0 100.0 73.3 100.0 100.0 100.0 100.0 100.0
    Task 7 10.0 43.3 6.7 31.0 100.0 100.0 100.0 100.0 76.7 100.0 100.0 100.0 100.0 100.0
    Task 8 13.3 53.8 20.0 70.2 96.7 100.0 93.3 100.0 66.7 99.8 100.0 100.0 100.0 100.0
    Task 9 0.0 0.0 0.0 0.0 93.3 100.0 0.0 0.0 30.0 85.7 100.0 100.0 100.0 100.0
    Task 10 0.0 0.0 0.0 0.0 100.0 100.0 83.3 100.0 46.7 96.9 100.0 100.0 100.0 100.0
    Task 11 0.0 0.0 0.0 0.0 3.3 16.7 0.0 0.0 0.0 0.0 100.0 100.0 100.0 100.0
    Task 12 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 13.3 57.1 13.3 57.1
    Task 13 0.0 0.0 0.0 0.0 3.3 16.7 0.0 0.0 0.0 0.0 100.0 100.0 100.0 100.0
    Task 14 0.0 0.0 0.0 0.0 6.7 31.0 0.0 0.0 0.0 0.0 73.3 100.0 73.3 100.0
    Task 15 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 13.3 57.1 13.3 57.1
    Task 16 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 6.7 33.3
    Task 18 0.0 0.0 0.0 0.0 0.0 0.0 3.3 16.7 0.0 0.0 0.0 0.0 100.0 100.0
    Task 19 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 60.0 99.8
    Task 20 0.0 0.0 0.0 0.0 0.0 0.0 3.3 16.7 0.0 0.0 0.0 0.0 100.0 100.0
    Task 21 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 20.0 73.6
    Tasks 17, 22–24 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
    Average 3.2 12.2 7.1 16.9 38.6 44.3 28.8 36.4 21.4 35.0 54.2 58.9 66.1 75.9
    # Solved 7 7 13 11 10 15 20

    Standard GPT-4o without the tool library solves 15 tasks (all basic circuits, Tasks 1–15) but fails on all composite tasks (Tasks 16–24). With the modular circuit tool library, AnalogCoder solves 20 out of 24 tasks, achieving a Pass@1 of 66.1% and a Pass@5 of 75.9%.

  7. Knowl 7 — Ablation Study and Fine-Tuning Evaluation on GPT-3.5

    data/table

    An ablation study evaluated the contribution of individual AnalogCoder components using GPT-3.5 as the baseline model, alongside 3-fold cross-validation fine-tuning of GPT-3.5 on successful designs:

    Method Pass@1 (%) Pass@5 (%) # Solved
    GPT-3.5 w/ SPICE 13.9 26.9 9
    GPT-3.5 w/o ICL 8.1 18.5 7
    GPT-3.5 w/o CoT 19.4 26.3 8
    GPT-3.5 w/o flow 12.8 25.3 8
    GPT-3.5 (Full flow) 21.4 35.0 10
    GPT-3.5 Finetune 28.1 39.6 10

    Key observations:

    • Prompting for native SPICE code rather than Python/PySpice drops Pass@1 from 21.4% to 13.9%.
    • Removing In-Context Learning (ICL) causes the largest performance degradation, reducing Pass@1 to 8.1%.
    • Removing the iterative feedback flow (w/o flow) decreases Pass@1 to 12.8% and drops solved tasks from 10 to 8.
    • Fine-tuning GPT-3.5 on clustered successful designs improves Pass@1 (28.1%) and Pass@5 (39.6%) by reducing syntax errors, but does not increase the total number of solved tasks beyond 10 due to base model capacity limits.

Coverage note — None was omitted. All contributed methodologies (Python/PySpice generation framing, prompt strategies, feedback-enhanced flow, tool library, fine-tuning procedure) and quantitative benchmark results were captured.

References

  1. 1.Achiam, J.; Adler, S.; Agarwal, S.; Ahmad, L.; Akkaya, I.; Aleman, F. L.; Almeida, D.; Altenschmidt, J.; Altman, S.; Anadkat, S.; et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774.
  2. 2.AI@Meta. 2024. Llama 3 Model Card.
  3. 3.Allen, P. E.; Dobkin, R.; and Holberg, D. R. 2011. CMOS analog circuit design. Elsevier.
  4. 4.Bai, J.; Bai, S.; Chu, Y.; Cui, Z.; Dang, K.; Deng, X.; Fan, Y.; Ge, W.; Han, Y.; Huang, F.; et al. 2023. Qwen technical report. arXiv preprint arXiv:2309.16609.
  5. 5.Blocklove, J.; Garg, S.; Karri, R.; and Pearce, H. 2023. Chip-chat: Challenges and opportunities in conversational hardware design. In ACM/IEEE 5th Workshop on Machine Learning for CAD (MLCAD), 1–6. IEEE.
  6. 6.Brown, T.; Mann, B.; Ryder, N.; Subbiah, M.; Kaplan, J. D.; Dhariwal, P.; Neelakantan, A.; Shyam, P.; Sastry, G.; Askell, A.; et al. 2020. Language models are few-shot learners. Advances in neural information processing systems (NeurIPS), 33: 1877–1901.
  7. 7.Cassano, F.; Gouwar, J.; Nguyen, D.; Nguyen, S.; Phipps-Costin, L.; Pinckney, D.; Yee, M.-H.; Zi, Y.; Anderson, C. J.; Feldman, M. Q.; et al. 2023. MultiPL-E: a scalable and polyglot approach to benchmarking neural code generation. IEEE Transactions on Software Engineering (TSE).
  8. 8.Chang, K.; Wang, Y.; Ren, H.; Wang, M.; Liang, S.; Han, Y.; Li, H.; and Li, X. 2023. Chipgpt: How far are we from natural language hardware design. arXiv preprint arXiv:2305.14019.
  9. 9.Chaoui, H. 1995. CMOS analogue adder. Electronics Letters, 31(3): 180–181.
  10. 10.Chen, M.; Tworek, J.; Jun, H.; Yuan, Q.; Pinto, H. P. d. O.; Kaplan, J.; Edwards, H.; Burda, Y.; Joseph, N.; Brockman, G.; et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374.
  11. 11.Chen, X.; Lin, M.; Schärli, N.; and Zhou, D. 2023. Teaching large language models to self-debug. arXiv preprint arXiv:2304.05128.
  12. 12.DeepSeek-AI. 2024. DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model. arXiv:2405.04434.
  13. 13.Dong, Q.; Li, L.; Dai, D.; Zheng, C.; Wu, Z.; Chang, B.; Sun, X.; Xu, J.; and Sui, Z. 2022a. A survey on in-context learning. arXiv preprint arXiv:2301.00234.
  14. 14.Dong, Z.; Cao, W.; Zhang, M.; Tao, D.; Chen, Y.; and Zhang, X. 2022b. CktGNN: Circuit Graph Neural Network for Electronic Design Automation. In The Eleventh International Conference on Learning Representations (ICLR).
  15. 15.Fu, Y.; Zhang, Y.; Yu, Z.; Li, S.; Ye, Z.; Li, C.; Wan, C.; and Lin, Y. C. 2023. Gpt4aigchip: Towards next-generation ai accelerator design automation via large language models. In 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD), 1–9. IEEE.
  16. 16.Guo, D.; Zhu, Q.; Yang, D.; Xie, Z.; Dong, K.; Zhang, W.; Chen, G.; Bi, X.; Wu, Y.; Li, Y.; et al. 2024. DeepSeek-Coder: When the Large Language Model Meets Programming–The Rise of Code Intelligence. arXiv preprint arXiv:2401.14196.
  17. 17.Hong, S.; Zheng, X.; Chen, J.; Cheng, Y.; Wang, J.; Zhang, C.; Wang, Z.; Yau, S. K. S.; Lin, Z.; Zhou, L.; et al. 2023. Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv:2308.00352.
  18. 18.Jiang, A. Q.; Sablayrolles, A.; Roux, A.; Mensch, A.; Savary, B.; Bamford, C.; Chaplot, D. S.; Casas, D. d. l.; Hanna, E. B.; Bressand, F.; et al. 2024. Mixtral of experts. arXiv preprint arXiv:2401.04088.
  19. 19.Johns, D. A.; and Martin, K. 2008. Analog integrated circuit design. John Wiley & Sons.
  20. 20.Khan, M. A. M.; Bari, M. S.; Do, X. L.; Wang, W.; Parvez, M. R.; and Joty, S. 2023. xcodeeval: A large scale multilingual multitask benchmark for code understanding, generation, translation and retrieval. arXiv preprint arXiv:2303.03004.
  21. 21.Krylov, D.; Khajeh, P.; Ouyang, J.; Reeves, T.; Liu, T.; Ajmal, H.; Aghasi, H.; and Fox, R. 2023. Learning to design analog circuits to meet threshold specifications. In International Conference on Machine Learning (ICML), 17858–17873. PMLR.
  22. 22.Kulal, S.; Pasupat, P.; Chandra, K.; Lee, M.; Padon, O.; Aiken, A.; and Liang, P. S. 2019. Spoc: Search-based pseudocode to code. Advances in Neural Information Processing Systems (NeurIPS), 32.
  23. 23.Li, R.; Zi, Y.; Muennighoff, N.; Kocetkov, D.; Mou, C.; Marone, M.; Akiki, C.; Jia, L.; Chim, J.; Liu, Q.; et al. 2023. StarCoder: may the source be with you! Transactions on Machine Learning Research (TMLR).
  24. 24.Li, Y.; Choi, D.; Chung, J.; Kushman, N.; Schrittwieser, J.; Leblond, R.; Eccles, T.; Keeling, J.; Gimeno, F.; Dal Lago, A.; et al. 2022. Competition-level code generation with alphacode. Science, 378(6624): 1092–1097.
  25. 25.Liu, C.; Liu, Y.; Du, Y.; and Du, L. 2024a. LADAC: Large Language Model-driven Auto-Designer for Analog Circuits. Authorea Preprints.
  26. 26.Liu, H.; Li, C.; Wu, Q.; and Lee, Y. J. 2024b. Visual instruction tuning. Advances in neural information processing systems (NeurIPS), 36.
  27. 27.Liu, J.; Xia, C. S.; Wang, Y.; and Zhang, L. 2024c. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation. Advances in Neural Information Processing Systems (NeurIPS), 36.
  28. 28.Liu, M.; Ene, T.-D.; Kirby, R.; Cheng, C.; Pinckney, N.; Liang, R.; Alben, J.; Anand, H.; Banerjee, S.; Bayraktaroglu, I.; et al. 2023a. Chipnemo: Domain-adapted llms for chip design. arXiv preprint arXiv:2311.00176.
  29. 29.Liu, M.; Pinckney, N.; Khailany, B.; and Ren, H. 2023b. Verilogeval: Evaluating large language models for verilog code generation. In 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD), 1–8. IEEE.
  30. 30.Liu, S.; Fang, W.; Lu, Y.; Zhang, Q.; Zhang, H.; and Xie, Z. 2023c. Rtlcoder: Outperforming gpt-3.5 in design rtl generation with our open-source dataset and lightweight solution. arXiv preprint arXiv:2312.08617.
  31. 31.Lu, Y.; Liu, S.; Zhang, Q.; and Xie, Z. 2024. RTLLM: An open-source benchmark for design rtl generation with large language model. In 2024 29th Asia and South Pacific Design Automation Conference (ASP-DAC), 722–727. IEEE.
  32. 32.Luo, Z.; Xu, C.; Zhao, P.; Sun, Q.; Geng, X.; Hu, W.; Tao, C.; Ma, J.; Lin, Q.; and Jiang, D. 2023. Wizardcoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568.
  33. 33.Lyu, W.; Yang, F.; Yan, C.; Zhou, D.; and Zeng, X. 2018. Batch Bayesian optimization via multi-objective acquisition ensemble for automated analog circuit design. In International conference on machine learning (ICML), 3306–3314. PMLR.
  34. 34.Olausson, T. X.; Inala, J. P.; Wang, C.; Gao, J.; and Solar-Lezama, A. 2023. Is Self-Repair a Silver Bullet for Code Generation? In The Twelfth International Conference on Learning Representations (ICLR).
  35. 35.Ousterhout, J. K. 1993. An Introduction to TCL and TK.
  36. 36.Pei, Z.; Zhen, H.-L.; Yuan, M.; Huang, Y.; and Yu, B. 2024. BetterV: Controlled Verilog Generation with Discriminative Guidance. arXiv preprint arXiv:2402.03375.
  37. 37.Poddar, S.; Budak, A.; Zhao, L.; Hsu, C.-H.; Maji, S.; Zhu, K.; Jia, Y.; and Pan, D. Z. 2024. A Data-Driven Analog Circuit Synthesizer with Automatic Topology Selection and Sizing. In Design, Automation & Test in Europe Conference & Exhibition (DATE), 1–6.
  38. 38.Qin, Y.; Liang, S.; Ye, Y.; Zhu, K.; Yan, L.; Lu, Y.; Lin, Y.; Cong, X.; Tang, X.; Qian, B.; et al. 2023. Toolllm: Facilitating large language models to master 16000+ real-world apis. arXiv preprint arXiv:2307.16789.
  39. 39.Razavi, B. 2000a. Design of Analog CMOS Integrated Circuits. McGraw-Hill, Inc.
  40. 40.Razavi, B. 2000b. Design of Analog CMOS Integrated Circuits. USA: McGraw-Hill, Inc., 1 edition. ISBN 0072380322.
  41. 41.Roziere, B.; Gehring, J.; Gloeckle, F.; Sootla, S.; Gat, I.; Tan, X. E.; Adi, Y.; Liu, J.; Remez, T.; Rapin, J.; et al. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950.
  42. 42.Salvaire, F. 2021. PySpice.
  43. 43.Sparck Jones, K. 1972. A statistical interpretation of term specificity and its application in retrieval. Journal of documentation, 28(1): 11–21.
  44. 44.Thakur, S.; Ahmad, B.; Pearce, H.; Tan, B.; Dolan-Gavitt, B.; Karri, R.; and Garg, S. 2023a. Verigen: A large language model for verilog code generation. ACM Transactions on Design Automation of Electronic Systems (TODAES).
  45. 45.Thakur, S.; Blocklove, J.; Pearce, H.; Tan, B.; Garg, S.; and Karri, R. 2023b. Autochip: Automating hdl generation using llm feedback. arXiv preprint arXiv:2311.04887.
  46. 46.Thomas, D.; and Moorby, P. 2008. The Verilog® hardware description language. Springer Science & Business Media.
  47. 47.Touvron, H.; Martin, L.; Stone, K.; Albert, P.; Almahairi, A.; Babaei, Y.; Bashlykov, N.; Batra, S.; Bhargava, P.; Bhosale, S.; et al. 2023. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288.
  48. 48.Tsai, Y.; Liu, M.; and Ren, H. 2023. Rtlfixer: Automatically fixing rtl syntax errors with large language models. arXiv preprint arXiv:2311.16543.
  49. 49.Vladimirescu, A. 1994. The SPICE book. John Wiley & Sons, Inc.
  50. 50.Wang, G.; Xie, Y.; Jiang, Y.; Mandlekar, A.; Xiao, C.; Zhu, Y.; Fan, L.; and Anandkumar, A. 2023. Voyager: An Open-Ended Embodied Agent with Large Language Models. In Intrinsically-Motivated and Open-Ended Learning Workshop@ NeurIPS2023.
  51. 51.Wang, H.; Wang, K.; Yang, J.; Shen, L.; Sun, N.; Lee, H.-S.; and Han, S. 2020. GCN-RL circuit designer: Transferable transistor sizing with graph neural networks and reinforcement learning. In 2020 57th ACM/IEEE Design Automation Conference (DAC), 1–6. IEEE.
  52. 52.Wei, J.; Wang, X.; Schuurmans, D.; Bosma, M.; Xia, F.; Chi, E.; Le, Q. V.; Zhou, D.; et al. 2022. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems (NeurIPS), 35: 24824–24837.
  53. 53.Wu, H.; He, Z.; Zhang, X.; Yao, X.; Zheng, S.; Zheng, H.; and Yu, B. 2024. Chateda: A large language model powered autonomous agent for eda. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (TCAD).
  54. 54.Yao, X.; Li, H.; Chan, T. H.; Xiao, W.; Yuan, M.; Huang, Y.; Chen, L.; and Yu, B. 2024. HDLdebugger: Streamlining HDL debugging with Large Language Models. arXiv preprint arXiv:2403.11671.
  55. 55.Yin, Y.; Wang, Y.; Xu, B.; and Li, P. 2024. ADO-LLM: Analog Design Bayesian Optimization with In-Context Learning of Large Language Models. arXiv preprint arXiv:2406.18770.
  56. 56.Zheng, Q.; Xia, X.; Zou, X.; Dong, Y.; Wang, S.; Xue, Y.; Shen, L.; Wang, Z.; Wang, A.; Li, Y.; et al. 2023. Codegeex: A pre-trained model for code generation with multilingual benchmarking on humaneval-x. In Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (SIGKDD), 5673–5684.
  57. 57.Zhong, R.; Du, X.; Kai, S.; Tang, Z.; Xu, S.; Zhen, H.-L.; Hao, J.; Xu, Q.; Yuan, M.; and Yan, J. 2023. LLM4EDA: Emerging Progress in Large Language Models for Electronic Design Automation. arXiv preprint arXiv:2401.12224.

Citation

MLA
Lai, Y., et al. “AnalogCoder: Analog Circuit Design via Training-Free Code Generation”. Proceedings of the AAAI Conference on Artificial Intelligence, vol. 39, no. 1, 2025, pp. 379–87, https://doi.org/10.1609/aaai.v39i1.32016.
APA
Lai, Y., Lee, S., Chen, G., Poddar, S., Hu, M., Pan, D. Z., & Luo, P. (2025). AnalogCoder: Analog Circuit Design via Training-Free Code Generation. Proceedings of the AAAI Conference on Artificial Intelligence, 39(1), 379–387. https://doi.org/10.1609/aaai.v39i1.32016
Chicago
Lai, Y., S. Lee, G. Chen, et al. 2025. “AnalogCoder: Analog Circuit Design via Training-Free Code Generation”. Proceedings of the AAAI Conference on Artificial Intelligence 39 (1): 379–87. https://doi.org/10.1609/aaai.v39i1.32016.
Harvard
Lai, Y. et al. (2025) “AnalogCoder: Analog Circuit Design via Training-Free Code Generation”, Proceedings of the AAAI Conference on Artificial Intelligence, 39(1), pp. 379–387. Available at: https://doi.org/10.1609/aaai.v39i1.32016.
Vancouver
1. Lai Y, Lee S, Chen G, Poddar S, Hu M, Pan DZ, Luo P (2025) AnalogCoder: Analog Circuit Design via Training-Free Code Generation. Proceedings of the AAAI Conference on Artificial Intelligence 39:379–387

BibTeX

@article{Lai_2025, title={AnalogCoder: Analog Circuit Design via Training-Free Code Generation}, volume={39}, ISSN={2159-5399}, url={http://dx.doi.org/10.1609/aaai.v39i1.32016}, DOI={10.1609/aaai.v39i1.32016}, number={1}, journal={Proceedings of the AAAI Conference on Artificial Intelligence}, publisher={Association for the Advancement of Artificial Intelligence (AAAI)}, author={Lai, Yao and Lee, Sungyoung and Chen, Guojin and Poddar, Souradip and Hu, Mengkang and Pan, David Z. and Luo, Ping}, year={2025}, month=Apr, pages={379–387} }
Metadata:Crossref

Source Code

This paper has an official code repository available. Click below to access the source code.

View Repository

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF