Releasing Soon · Public preview

Circuit simulation,
reimagined for AI.

CircuitGPT is a modern, SPICE-compatible analog & mixed-signal simulator written in Go — programmable, scriptable, and built from the ground up to be driven by language models.

Request early access See it in action

No credit card. No spam. We’ll email you when the beta opens.

circuitgpt — ~/projects/amplifier ⌘ K

common_emitter.cir .tran

* Common-emitter amplifier — small signal
.model QN NPN(Bf=220 Is=1e-15 Va=75)

Vcc   vcc 0    DC 9
Vin   in  0    SIN(0 10m 10k)
Rc    vcc c    4.7k
Re    e   0    470
R1    vcc b    47k
R2    b   0    10k
Cin   in  b    1u
Cout  c   out  1u
Q1    c   b    e QN

.tran 2u 2m
.print tran v(out) v(in)
.end

$ circuitgpt run ok

time v(in) v(out)

0.000e+0 +0.0000 +4.213

2.500e-5 +1.566m +4.124

5.000e-5 +2.939m +3.962

7.500e-5 +3.961m +3.747

1.000e-4 +4.524m +3.498

…

v(in) v(out)

gain ≈ −7.8 V/V

// What it does

A simulator built for the next era of EDA.

Every detail — from the netlist parser to the JSON output schema — is designed so that humans and AI agents can read, reason about, and modify circuits together.

SPICE-compatible netlists

Drop in your existing .cir files. R, L, C, diodes, BJTs, MOSFETs, controlled sources, subcircuits, .param, .include, .lib.

All the analyses you need

Operating point, DC sweeps, AC small-signal, transient, and noise — with Newton-Raphson, gmin and source stepping for tough nonlinear circuits.

AI-native by design

Clean JSON in. Clean JSON out. Structured errors. Deterministic results. Built so language models can author, simulate, and refine circuits in a tight loop.

Reference-checked

Built-in conformance comparisons against ngspice and Xyce, with configurable relative and absolute tolerances on selected vectors.

DigiKey-aware

Pull real part data straight from DigiKey — MPNs, datasheets, stock — and feed it into a symbol/footprint pipeline ready for downstream layout tools.

Headless & embeddable

One static binary. CLI, HTTP server, and Go API in the same artifact. Drop it into pipelines, notebooks, agents, or your own EDA stack.

// Workflow

From netlist to numbers in one command.

CircuitGPT reads standard SPICE-style netlists and emits structured, machine-readable results. Pipe it into your favorite tool — or into a model.

Run any .cir with a single subcommand.
Compare against ngspice or Xyce with one flag.
Serve simulations through a built-in HTTP API.
Embed directly via the Go API in your own agent.

zsh — circuitgpt

$ circuitgpt run divider.cir --format json
{
  "analysis": "op",
  "vectors": {
    "v(in)":  5.000000,
    "v(out)": 2.500000,
    "i(V1)":  -2.500e-04
  },
  "elapsed_ms": 1.4
}

$ circuitgpt compare rc_ac.cir --against ngspice
✓ v(out) within reltol=1e-3   (81 pts)
✓ v(in)  within reltol=1e-3   (81 pts)
match: ngspice 42 / xyce 7.8

$ circuitgpt serve --addr :8080
→ POST /api/simulate     accepts .cir, returns JSON
→ POST /api/compare      reference-checks against ngspice
→ listening on :8080

// Capabilities

Production-shaped, today.

The preview release already covers the analog primitives most circuits need. Here’s what ships on day one.

v0 preview · subject to change

Devices

Resistors, capacitors, inductors
Shockley diodes
NPN & PNP BJTs (Ebers-Moll)
NMOS & PMOS (Level 1, body effect)
E / G / F / H controlled sources

Analyses

DC operating point (.op)
DC sweep (.dc)
Small-signal AC (.ac)
Transient (.tran)
Noise analysis (.noise)

Solver

Newton-Raphson nonlinear loop
Source & gmin stepping fallbacks
Tunable reltol, abstol, vntol
.nodeset / .ic hints
Adaptive timestep transient

Tooling

CLI: run · check · compare
HTTP API + web UI
JSON & CSV outputs
Vendor library ingestion
DigiKey part search & pipeline

// Roadmap

What’s next.

Now — v0 preview

Core analog simulator

Devices, analyses, solver, CLI, and HTTP API. Reference comparisons against ngspice and Xyce. JSON-first I/O for agents.
Next

Sparse-matrix solver & performance

Sparse LU, reordering, and parallelism to scale to large boards without losing the clean architecture.
Next

Vendor macro-model execution

Run vendor SPICE subcircuits straight from the manufacturer’s library — op-amps, references, regulators — out of the box.
Later

AI-assisted circuit refinement

The original mission: language models that propose circuit edits, simulate them, and converge on a working design — with you in the loop.

// Releasing soon

Be the first to run CircuitGPT.

Drop your email and we’ll send you the beta link the moment it’s live.

By signing up you agree to receive a single email when CircuitGPT launches. We will not share your address.

Circuit simulation, reimagined for AI.