neospice

Open Circuit Lab → — build and simulate circuits in your browser. No installation required.

neospice is an independent C++20 reimplementation of the SPICE circuit simulator. Its solver, analysis flow, and device models derive from UC Berkeley SPICE3 (BSD-licensed) and ngspice -- re-architected around a clean Device interface, native Python bindings, and an embeddable C++ API. MIT licensed; see NOTICE for full third-party attribution.

It reads SPICE netlists, writes ngspice-format raw results, and pairs a self-contained Sparse 1.3-compatible solver stack and differentiated behavioral sources with an embeddable API for EDA tools, optimization loops, and notebooks.

Version 0.2.0 is a beta release; 1.0 is reserved for further stability work. See the release notes. Publication validation targets ngspice 47 exclusively. Known model limitations and corpus mismatches remain; see the progress tracker and comparison methods. The project is not yet ready for a JOSS submission.

An initial JOSS manuscript draft and PDF are available for review. Actual research evidence, final validation/benchmarks and human disclosures remain pending. ngspice 47 compatibility defines the default behavior, required reference checks and migration-tool inputs. A compiled draft is not a submission-ready release.

Features

• Analyses -- DC OP, DC sweep, transient (adaptive Trap/Gear-2/BE), AC small-signal, noise (adjoint method), transfer function, sensitivity, pole-zero, Fourier/THD, parameter sweep (.step), and .measure post-processing
• Device families -- passives, independent/dependent/behavioral sources, switches, transmission lines, diodes, BJTs, JFETs, MESFETs, HFETs, and MOSFETs through BSIM4v7
• Embeddable C++ API -- Simulator/Circuit/Result types with handle-based and string-based accessors, typed device methods, and circuit introspection
• High performance -- NeoSolver (self-contained Sparse 1.3-compatible LU), G/C matrix caching for AC, adjoint-method noise
• ngspice-compatible -- reads standard SPICE netlists, writes .raw files in ngspice format
• C++ and Python validation -- analytical checks and ngspice comparisons, with current failures and test results in the progress tracker
• Corpus harness -- a historical cohort of 34,908 KiCad operating-point fixtures; input freezing now records declaration identities and separate planned rescues. Completed ngspice 47 audits are linked from the progress tracker; declaration binding and full-model scope still need interpretation. Minimal operating-point fixtures do not certify transient, AC, or noise behavior.

Browser Circuit Lab

Launch Circuit Lab

Build and simulate circuits in a visual schematic editor, or use an editable SPICE netlist. Circuit Lab includes eight interactive examples, light/dark themes, DC/AC/transient plots, parameter tuning, local project saving, and CSV export. The simulator runs entirely in your browser using WebAssembly.

# Build the WASM artifacts first; see docs/webassembly.md.
npm --prefix web ci
npm --prefix web run build
npm --prefix web run preview

Open http://127.0.0.1:48173/. The Circuit Lab guide covers the visual editor, external preview tunnel, tests and manual GitHub Pages deployment. The existing minimal WASM demo is also retained.

Quick Start (C++)

Prerequisites

• C++20 compiler (GCC 12+ or Clang 15+)
• CMake 3.20+
• OpenBLAS
• SLEEF (vectorized math library)

See docs/building.md for platform-specific install commands.

Build

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j$(nproc)

Run

# Simulate a netlist
./build/neospice circuit.cir

# Specify output file
./build/neospice circuit.cir -o result.raw

# Split output by analysis type
./build/neospice circuit.cir --split

Output is written in ngspice-compatible .raw format, viewable in any waveform viewer (e.g. GTKWave, KST, ngspice's built-in plot).

Test

cd build && ctest -j$(nproc)

Analyses

Device Models

AM source parameters now follow ngspice 47. Existing AM netlists and C++ source parameters may require conversion; see source compatibility.

C++ API

Running a netlist

#include "neospice/neospice.hpp"

neospice::Simulator sim;
auto ckt = sim.load("amplifier.cir");
auto result = sim.run(ckt);

// Typed access to results
auto& ac = std::get<neospice::ACResult>(result.analysis);
auto gain_db = ac.magnitude_db("out");
auto phase = ac.phase_deg("out");

Individual analyses

auto dc = sim.run_dc(ckt);
double vout = dc.voltage("out");

auto tran = sim.run_transient(ckt, 1e-9, 1e-6);
auto vout_wave = tran.voltage("out");   // vector<double>

auto ac = sim.run_ac(ckt, neospice::ACMode::DEC, 10, 1.0, 100e6);
auto gain = ac.magnitude_db("out");     // vector<double>

Building circuits programmatically

using namespace neospice;

Circuit ckt;
auto in  = ckt.node("in");
auto out = ckt.node("out");

ckt.V("V1", in, GND, 0.0, 1.0);  // DC=0, AC=1
ckt.R("R1", in, out, 1e3);
ckt.C("C1", out, GND, 100e-12);

Simulator sim;
auto ac = sim.run_ac(ckt, ACMode::DEC, 10, 1.0, 100e6);
auto gain = ac.magnitude_db("out");

Handle-based result access

// String-based (works with any circuit)
double vout = dc.voltage("out");

// Handle-based (O(1) dense array access, type-safe)
NodeId out_id = ckt.find_node("out");
double vout_h = dc.voltage(out_id);
auto vout_ac  = ac.magnitude_db(out_id);

Measurement utilities

#include "neospice/measure.hpp"

NodeId out_id = ckt.find_node("out");
double bw     = measure::bandwidth_3db(ac, out_id);
double rt     = measure::rise_time(tran, out_id, 0.5, 4.5);
double st     = measure::settling_time(tran, out_id, 5.0, 0.05);
double vrms   = measure::rms(tran, out_id);

Circuit introspection

auto nodes   = ckt.node_names();            // {"in", "out", ...}
auto devices = ckt.device_names();          // {"R1", "C1", "V1"}
auto info    = ckt.device_info("R1");       // type, nodes, value
auto conn    = ckt.devices_at_node("out");  // {"R1", "C1"}

// Handle-based introspection
NodeId nid   = ckt.find_node("out");
DevId  did   = ckt.find_device("R1");
auto   name  = ckt.name(nid);              // "out"
auto   dinfo = ckt.device_info(did);       // DeviceInfo struct

Python

pip install neospice

Prebuilt wheels are published for CPython 3.10–3.14 on Linux (x86_64, aarch64) and macOS Apple Silicon (arm64). On other platforms pip builds from the source distribution, which needs a C++20 compiler plus OpenBLAS and SLEEF.

import neospice as ns
import matplotlib.pyplot as plt

# One-liner convenience functions
dc = ns.dc("amplifier.cir")
print(dc.voltage("out"))

ac = ns.ac("filter.cir", mode="dec", npoints=100, fstart=1, fstop=1e9)
plt.semilogx(ac.frequency, ac.magnitude_db("out"))

tran = ns.transient("osc.cir", tstep=1e-9, tstop=1e-6)
plt.plot(tran.time, tran.voltage("out"))

# Parse inline netlists directly
dc = ns.dc("Divider\nV1 in 0 DC 10\nR1 in mid 1k\nR2 mid 0 1k\n.op\n.end\n")
print(dc.voltage("mid"))  # 5.0

# Or use the full Simulator API
sim = ns.Simulator()
ckt = sim.load("amplifier.cir")          # from file
ckt = sim.parse("...\n.op\n.end\n")      # or from string
result = sim.run_ac(ckt, ns.ACMode.DEC, 100, 1, 1e9)

# Build circuits programmatically with typed methods
ckt = ns.Circuit()
ckt.V("V1", "in", "0", 0.0, 1.0)        # DC=0, AC=1
ckt.R("R1", "in", "out", 1e3)
ckt.C("C1", "out", "0", 100e-12)

# SPICE engineering notation
from neospice import parse_value
r = parse_value("4.7k")                  # 4700.0

All result vectors are returned as NumPy arrays.

Browser simulation

Build neospice.wasm and its JavaScript module with Emscripten. The included Worker demo supports netlist editing, DC/AC/transient simulation and resistor sliders. Build instructions, JS/TypeScript API and limits.

Gradients and interactive updates

Use Simulator.sensitivity() for DC adjoint Jacobians and sensitivity_ac() for linear-circuit complex AC gradients. Supported parameters and examples. For repeated component changes, Circuit.update_param() with re_solve() or re_solve_ac() reuses per-circuit symbolic factorization. Incremental workflow.

Parallel parameter studies

Run independent parameter corners with neospice.sweep() or seeded variations with neospice.monte_carlo(). The C++ API provides Simulator::run_sweep() and Simulator::monte_carlo(). Results preserve job order and report per-job errors. See parallel studies for examples, correlation, statistics, reproducibility and concurrency limits.

Performance

The paired benchmark covers 34 fixed workloads: small circuits, amplifier macromodels, larger resistor meshes and diode ladders, and RC/diode-RC analyses. Every accepted timing requires valid, accuracy-qualified results from both engines. The protocol records load, analysis/result materialization, cleanup and total time with equal sampling and alternating execution order.

See benchmark methods for reproduction and the progress tracker for completed evidence and active runs. Historical timings from the former harness are archived; they lack the corrected qualification protocol and must not support performance claims. Performance analysis explains the limits.

Netlist Compatibility

Beyond core devices and analyses, neospice handles the usual deck directives and syntax:

• .param expressions with arithmetic, functions (sqrt, log, exp, sin, if, ...)
• .subckt / .ends with parameter defaults (recursion limit 100)
• .include / .lib with section selection and circular-inclusion detection
• .global, .ic, .nodeset, .options, .func, .save
• SPICE suffixes: T, G, MEG, k, m, u, n, p, f

Project Structure

cli/            Command-line interface
include/
  neospice/     Public API headers (types.hpp, neospice.hpp, measure.hpp)
src/
  api/          C++ API (Simulator, typed device methods, measurement utils)
  core/         Analysis engines and linear solvers
  devices/      32 device models, each self-contained with factory registration
  parser/       Netlist parser and expression evaluator
  output/       Raw file writer
python/
  bindings.cpp  nanobind C++ → Python bridge
  neospice/     Python package (convenience API, SPICE notation parser)
tests/
  unit/         Unit tests for all components (970+)
  devices/      Per-device validation against ngspice
  circuits/     Integration test netlists
  python/       Python binding tests
  bench/        Performance benchmarks
docs/           Architecture, performance, and design documentation
tools/          Device migration tooling (ngspice model auto-porter)

Examples

Comparator Relaxation Oscillator

A TLV3201-based Schmitt trigger oscillator simulated with the Python API. Comparator relaxation oscillator.

Contributing

See docs/building.md for platform-specific setup instructions, including building libngspice from source on macOS.

Documentation

• Performance comparison with ngspice
• Algorithmic differences from ngspice
• Device migration status
• Capabilities overview
• Architecture and design

Roadmap

See docs/ROADMAP.md for details.

Credits & SPICE lineage

neospice descends from the Berkeley SPICE family. It is an independent C++20 reimplementation, but its solver, analysis flow, and device models are derived — in many places translated — from UC Berkeley SPICE3 and ngspice. We gratefully acknowledge that lineage:

• L. W. Nagel and D. O. Pederson, "SPICE (Simulation Program with Integrated Circuit Emphasis)," Memorandum No. ERL-M382, UC Berkeley, April 1973.
• L. W. Nagel, "SPICE2: A Computer Program to Simulate Semiconductor Circuits," Memorandum No. ERL-M520, UC Berkeley, May 1975.
• SPICE2G6 (1983) — the Fortran reference release.
• SPICE3F5 (UC Berkeley, 1990s) — the BSD-licensed C rewrite that neospice's core and device code is translated from.
• ngspice — the maintained SPICE3F5 descendant, used as the reference/ground-truth implementation that neospice is validated against.

The NeoSolver sparse-LU stack derives from Kenneth Kundert's Sparse 1.3 (UC Berkeley). The separate in-tree minimum-degree ordering explicitly maintains the elimination graph and uses the default dense-vertex threshold from SuiteSparse AMD; it does not implement SuiteSparse AMD's quotient-graph algorithm.

Original project contributions use the MIT license. Derived SPICE code and device models retain applicable upstream notices and terms. See NOTICE, CREDITS.md, and the distribution audit.

The JOSS benchmark protocol and its current qualification failures are documented in paired benchmark methods. Historical standalone benchmark timings are not yet publication evidence.