NeuroSPICE: When Circuits Stop Ticking and Start Thinking

Opening — Why this matters now

Circuit simulation has always been an exercise in controlled compromise. We discretize time, linearize nonlinearity, and hope the numerical solver behaves. SPICE has done this extraordinarily well for decades—but it was built for an era where devices were mostly electrical, mostly local, and mostly cooperative.

That era is ending. Ferroelectrics, photonics, thermal coupling in 3D ICs, and other strongly nonlinear or multi-physics effects are turning compact modeling into a brittle art. Against this backdrop, NeuroSPICE proposes something mildly heretical: stop stepping through time altogether.

Background — What existed before

Traditional SPICE simulators solve circuit differential-algebraic equations (DAEs) using time discretization and numerical integration schemes such as backward Euler. This approach is fast, battle-tested, and highly optimized—but also rigid:

• Device models must conform to simulator interfaces (often via Verilog-A)
• Multi-physics coupling is awkward and error-prone
• Gradients with respect to design parameters are not natively available

In parallel, machine learning has matured beyond pure curve fitting. Physics-Informed Neural Networks (PINNs) embed governing equations directly into the loss function, solving differential equations without labeled data. PINNs have been explored in power systems and device modeling—but circuit-level simulation remained untouched territory.

Analysis — What NeuroSPICE actually does

NeuroSPICE reframes circuit simulation as a function approximation problem over time.

Instead of stepping from $t$ to $t+\Delta t$, a neural network takes time itself as input and outputs node voltages (and optionally branch currents) as continuous analytical functions of time. The circuit DAEs and initial conditions form the loss function. Automatic differentiation provides exact temporal derivatives like $dV/dt$ and $dQ/dt$.

In short:

Device models are written directly in Python. Currents, charges, and internal states are returned explicitly, with derivatives computed analytically by the ML framework—not approximated numerically.

This is not just a technical tweak. It fundamentally changes where modeling complexity lives: from simulator internals to user-level code.

Findings — What works (and what doesn’t)

The paper evaluates NeuroSPICE on three progressively harder cases:

Key observations:

• NeuroSPICE closely matches HSPICE waveforms for linear and nonlinear circuits
• It can handle unstable, self-oscillating systems
• Highly nonlinear physics (e.g., ferroelectric switching) require careful tuning and longer training
• Training is much slower than SPICE
• Inference is fast (~200 μs) once trained

This leads to an important conclusion the authors do not oversell: NeuroSPICE is not a SPICE replacement.

Implications — Where this actually matters

NeuroSPICE shines where traditional simulators struggle:

1. Emerging device prototyping No Verilog-A. No simulator-specific hacks. Just physics in Python.

2. Multi-physics coupling Electrical, thermal, ferroelectric, photonic—expressed in a single differentiable framework.

3. Differentiable circuit surrogates Once trained, NeuroSPICE becomes a gradient-friendly proxy for inverse design and optimization.

This is the quiet strategic shift: not faster simulation, but new capabilities. In an era where optimization loops increasingly matter more than single-run accuracy, differentiability is currency.

Conclusion — A simulator that thinks differently

NeuroSPICE does not beat SPICE at its own game—and wisely doesn’t try. Instead, it reframes circuit simulation as a continuous, differentiable modeling problem, better aligned with modern optimization and emerging device research.

If SPICE is a stopwatch, NeuroSPICE is a calculus notebook. Slower, more abstract—but capable of answering questions the stopwatch never could.

Cognaptus: Automate the Present, Incubate the Future.