NeuroSPICE: When Circuits Stop Ticking and Start Thinking

A circuit simulator normally moves forward one small step at a time.

Calculate the voltages now. Advance the clock. Calculate them again. Repeat until the simulated waveform reaches the end of the requested interval—or until the solver discovers a particularly creative reason to stop converging.

NeuroSPICE proposes a different arrangement. Instead of calculating a circuit’s state sequentially across discrete time steps, it trains a neural network to represent the circuit’s entire waveform as a continuous function of time.¹

That sounds suspiciously like replacing an excellent engineering tool with an elaborate machine-learning demonstration. The suspicion is reasonable. Commercial SPICE simulators are fast, mature, and deeply embedded in semiconductor design workflows. NeuroSPICE does not outperform them at ordinary circuit simulation, and its authors explicitly say it should not be treated as a direct replacement.

Its more interesting contribution lies elsewhere.

By turning circuit equations into a training objective, NeuroSPICE moves device modeling into a Python-based, automatically differentiable environment. The resulting simulator is slower to construct, but potentially easier to extend toward unusual devices, coupled physical systems, inverse problems, and gradient-based design optimization.

The important question is therefore not whether neural networks can beat SPICE at SPICE’s own job.

It is whether circuit simulation becomes useful for different jobs once the waveform itself becomes a differentiable model.

A Circuit Simulator Usually Marches Through Time

Transient circuit simulation begins with equations describing how currents, voltages, charges, and device states interact.

For a circuit with dynamic components, those relationships commonly form a system of differential-algebraic equations. A simplified representation is:

Here, $v(t)$ represents circuit variables such as node voltages, $q$ captures stored charge, $f$ represents device and network relationships, and $b(t)$ represents external inputs.

A conventional transient SPICE solver does not generally solve for the entire function $v(t)$ in one operation. It divides time into steps, approximates the dynamic terms using numerical integration, solves the resulting equations at each step, and advances.

This approach is exceptionally effective. Decades of development have produced sophisticated handling for nonlinear devices, stiff systems, convergence problems, adaptive time steps, and industrial-scale circuits.

But the approach also determines where complexity must live.

Device models must fit the interfaces and numerical expectations of the simulator. Researchers working with emerging devices may need not only a correct physical model, but also sufficient knowledge of compact modeling, Verilog-A, numerical stability, and simulator behavior to make that model usable.

That requirement becomes more awkward when a device combines electrical behavior with ferroelectric, photonic, thermal, or other physical processes. The equations may be clear. Persuading an established simulation workflow to accept them can be the less elegant part.

NeuroSPICE changes this division of labor.

The Waveform Becomes the Neural Network

NeuroSPICE uses time, $t$, as the input to a neural network. The outputs are the circuit quantities that would normally be solved by the simulator, such as node voltages and selected branch currents:

The network is therefore not predicting the next time step from the previous one. It is attempting to represent the complete waveform over the simulation interval.

During training, NeuroSPICE evaluates the network at a collection of time points. It substitutes the predicted voltages and currents into the circuit’s governing equations, calculates how badly those equations are violated, and adjusts the neural-network parameters to reduce the violations.

The basic loop is:

1. Provide sampled time points to the network.
2. Generate predicted node voltages and branch quantities.
3. Evaluate device equations and Kirchhoff’s current law.
4. Measure the residuals of the circuit equations.
5. Penalize violations of the initial conditions.
6. Update the network parameters through backpropagation.

No labeled waveform dataset is required. The circuit equations provide the supervision.

This corrects one likely misunderstanding about the term “neural circuit simulator.” NeuroSPICE is not trained by collecting thousands of HSPICE outputs and asking a model to imitate them. HSPICE is used as the reference for evaluating the demonstrations, but the NeuroSPICE loss is built from physics equations and initial conditions.

Its neural network learns because incorrect waveforms fail to obey the circuit.

The Loss Function Replaces the Solver Loop

In NeuroSPICE, the circuit’s differential-algebraic equations become residual terms in the training loss.

Suppose Kirchhoff’s current law requires the currents entering and leaving a node to balance. NeuroSPICE calculates the current imbalance produced by its predicted waveform. A correct solution should drive that imbalance toward zero.

The paper describes the total objective as a weighted combination of the DAE residual loss and the initial-condition loss:

The DAE term asks whether the predicted waveform follows the circuit equations. The initial-condition term prevents the network from finding a mathematically permissible trajectory that begins from the wrong state.

The weights $\alpha$ and $\beta$ matter because the optimizer must satisfy different types of constraints simultaneously. A network that minimizes equation residuals while neglecting the initial condition is not useful. Nor is a network that begins correctly and then violates the circuit dynamics.

This is where NeuroSPICE exchanges one class of numerical problem for another.

Traditional SPICE requires careful numerical integration, linearization, and convergence handling. NeuroSPICE avoids that conventional time-stepping machinery, but it must instead train an optimization model whose loss landscape may be difficult to navigate.

The solver did not disappear. It changed profession.

“Exact Derivatives” Means Exact for the Learned Waveform

One of NeuroSPICE’s central technical advantages is automatic differentiation.

Because the network represents voltage as an explicit differentiable function $\hat{v}_{\theta}(t)$, a framework such as PyTorch can calculate derivatives including:

These derivatives are obtained through the neural network’s computational graph rather than through finite-difference approximations between neighboring time steps.

The paper describes them as exact analytical temporal derivatives. That description needs one qualification: the derivatives are exact with respect to the waveform represented by the trained network. Whether that learned waveform accurately represents the physical circuit remains an empirical question.

The distinction matters because “automatic differentiation” can sound like a guarantee of simulation accuracy. It is not. It guarantees that the derivative calculation is consistent with the current neural representation. If the network has converged to an inaccurate waveform, it can provide a beautifully precise derivative of the wrong answer.

Still, the capability changes what can be expressed inside the simulator.

A device model written in Python can return currents, charges, and internal quantities. Automatic differentiation can then propagate through those relationships without requiring the model developer to manually construct every numerical derivative or adapt the equations to a conventional transient-integration interface.

For research teams experimenting with unfamiliar device physics, that is a meaningful shift.

Device Physics Moves Into User-Level Python

The paper contrasts NeuroSPICE’s device-modeling environment with conventional compact-model workflows.

A typical production-grade compact model may be implemented in Verilog-A and evaluated inside a simulator whose internal numerical behavior is largely outside the model developer’s control. NeuroSPICE instead allows device equations to be written directly in Python and connected to the physics-informed loss.

The practical attraction is not that Python is inherently superior to Verilog-A. It is that Python sits inside an ecosystem where automatic differentiation, neural optimization, scientific computing, and experimental model construction are already readily available.

This can shorten the path from a physical equation to a working circuit-level experiment.

It can also shift the required expertise. A team may need less knowledge of simulator-specific model implementation, but more knowledge of neural-network optimization, loss balancing, architecture selection, and convergence diagnosis.

The barrier may become lower for some researchers. It does not necessarily vanish.

Three Demonstrations Test Three Different Questions

The paper evaluates NeuroSPICE on three small cases: a transistor amplifier, a five-stage ring oscillator, and a ferroelectric memory cell.

These demonstrations should not be read as three interchangeable accuracy benchmarks. Each tests a different part of the proposal.

The paper contains no architecture ablation, seed-robustness study, circuit-size scaling experiment, or quantified error comparison. Its evidence is best understood as a feasibility demonstration.

That does not make it unimportant. It determines which conclusions the evidence can carry without collapsing under the weight.

The Transistor Amplifier Establishes the Basic Mechanism

The first test is a transistor amplifier whose node equations are built by applying Kirchhoff’s current law.

NeuroSPICE predicts the relevant voltages as functions of time. The MOSFET model supplies device currents and charges. Automatic differentiation provides terms such as $dV/dt$ and $dQ/dt$. The resulting residuals become the loss.

The paper compares the predicted drain and gate voltage waveforms with HSPICE and reports close agreement. The plotted NeuroSPICE curves visually follow the HSPICE reference points.

This is the most basic claim the paper needs to establish: a neural network trained from the circuit equations can recover a plausible transient waveform without being given labeled simulation data.

The result does not show that NeuroSPICE is more accurate than SPICE. HSPICE is the reference. Nor does the paper report numerical error measures that would allow a reader to evaluate small discrepancies.

The amplifier demonstration shows that the proposed mechanism works on a simple case. It is the entry ticket, not the trophy.

The Ring Oscillator Tests Whether the Network Can Find a Rhythm

A ring oscillator is more revealing because its behavior is generated by the circuit itself.

There is no externally supplied sinusoidal waveform for the model to imitate. The circuit’s nonlinear dynamics must produce a repeating oscillation, with each stage switching in sequence.

The five-stage ring-oscillator result shows NeuroSPICE waveforms closely following the HSPICE reference across the oscillating nodes. The authors interpret this as evidence that the method can simulate unstable, self-oscillating systems and solve DAEs containing multiple nonlinear device models.

This is stronger evidence than another passive or externally driven circuit would have provided. The network must represent the timing relationships and repeating state transitions generated by the coupled system.

But the experiment remains one oscillator with one set of training choices. It does not show how often training fails, how sensitive the phase and frequency are to initialization, or whether convergence becomes unreliable as the number of stages grows.

For a feasibility paper, the demonstration is appropriately chosen. For an industrial solver, it is the beginning of a much longer conversation.

The FeRAM Case Shows Why Python-Level Physics Is the Real Pitch

The third demonstration is the paper’s most strategically relevant example.

Ferroelectric devices are attractive for applications such as low-power memory and in-memory computing, but their dynamics are strongly nonlinear. The paper uses the Landau–Khalatnikov model to describe ferroelectric polarization and couples it with a MOSFET model in a FeRAM cell.

NeuroSPICE reproduces the voltage drop associated with polarization switching in the ferroelectric capacitor, with the plotted waveforms closely following HSPICE.

The result matters less as another visual match and more as an illustration of modeling workflow.

The Landau–Khalatnikov equation can be expressed directly in DAE form inside NeuroSPICE. The model developer does not need to first package the physics into a conventional simulator interface before testing it at circuit level.

This is where the paper’s business relevance begins to emerge. Research organizations frequently need to evaluate devices before their modeling workflows have matured into standardized, production-quality compact models. A Python-native differentiable environment could provide a faster route from physical hypothesis to circuit-level exploration.

The evidence, however, remains limited to one emerging-device example. The paper mentions possibilities such as photonic elements and three-dimensional thermal coupling, but it does not demonstrate them.

FeRAM supports the direction. It does not validate the entire category.

Training Is Slower, and the Paper Does Not Pretend Otherwise

All three cases use a four-layer fully connected neural network with 50 neurons in each hidden layer, Tanh activation functions, the Adam optimizer, and an NVIDIA Quadro Pro GPU.

The training settings and reported runtimes are:

The FeRAM case requires substantially more epochs and a smaller learning rate, which the authors attribute to its highly nonlinear physics. The ring oscillator takes longer than the amplifier despite using fewer epochs, demonstrating that epoch count alone does not determine computational cost.

The authors state plainly that NeuroSPICE training is slower than commercial SPICE. They point to Python’s slower execution relative to optimized C or C++ implementations and to the larger internal matrices used by the PINN compared with a circuit’s nodal matrices.

This removes the easiest but least useful business interpretation.

NeuroSPICE is not currently a cheaper way to run an ordinary transient simulation once.

Its economic case would need to come from what happens after training, from what becomes easier to model, or from capabilities that conventional simulation workflows do not expose conveniently.

Fast Inference Is Useful Only When the Training Cost Can Be Amortized

The paper reports inference times of approximately 200 microseconds across the three demonstrations. Once trained, the network can evaluate its analytical waveform rapidly.

That number is promising, but it should not be confused with a demonstrated end-to-end speed advantage.

In the presented experiments, minutes of training precede microseconds of inference. A conventional SPICE run may therefore remain far more efficient when the objective is simply to simulate one circuit under one condition.

Fast inference becomes economically relevant when the trained model can be reused many times.

Possible reuse scenarios include:

• repeatedly querying a circuit waveform during an optimization process;
• evaluating many candidate designs;
• embedding a circuit surrogate inside a larger system model;
• rapidly exploring combinations of design parameters;
• solving inverse problems where desired outputs are used to infer suitable inputs or component values.

However, the demonstrations train the networks for the presented circuit cases. The paper proposes extending the network inputs to include design parameters, but it does not demonstrate a parameterized surrogate trained across a design space.

That extension is essential.

A model that quickly reproduces one already-trained waveform is an interesting representation. A model that accurately predicts waveforms across many unseen parameter combinations would be an operational surrogate.

NeuroSPICE shows the architecture of that possibility, not the completed asset.

Differentiability Is the Strategic Capability

The paper’s most important prospective advantage is not neural simulation. It is differentiable simulation.

Suppose a design objective depends on a waveform produced by a circuit:

where $p$ represents design parameters such as component values, device dimensions, or material properties.

If the trained simulator accepts $p$ as an input and remains differentiable through the relevant equations, gradients such as

could be calculated and used for gradient-based optimization.

This offers a different way to search a design space. Instead of repeatedly changing parameters, running a simulator, and estimating which direction improves the result, an optimization system could obtain directional information directly through the differentiable surrogate.

The paper identifies inverse design and gradient-based optimization as potential uses. It does not perform either one experimentally.

The distinction should remain visible:

Differentiability is therefore a credible research direction, not yet a measured productivity gain.

The Business Value Is Modeling Flexibility, Not Faster SPICE

NeuroSPICE suggests three practical pathways for engineering organizations.

1. Faster prototyping of emerging-device models

Researchers can express device equations directly in Python and connect them to circuit-level DAEs without first developing a complete simulator-specific compact model.

The likely operational benefit is a shorter cycle between proposing new device physics and observing its circuit-level consequences.

The uncertainty is whether time saved on Verilog-A implementation will be offset by time spent tuning the neural solver and validating its results.

2. A shared environment for coupled physical models

Because the loss can incorporate different governing equations, NeuroSPICE could provide a common differentiable environment for electrical behavior and additional physical processes.

The paper’s FeRAM demonstration offers a narrow example of this flexibility. Broader claims involving thermal, photonic, spatial, or higher-order systems remain prospective.

The potential value is easier technology-system co-exploration before standardized modeling tools exist.

3. Differentiable surrogates for repeated optimization

A trained, parameterized model could support fast repeated evaluations and gradient-based design searches.

This pathway has the strongest long-term economic appeal because optimization workflows may require thousands or millions of model queries. A costly training phase can be rational if it materially reduces the cost of the larger search process.

But that argument depends on results not yet presented: reliable parameter-space generalization, measurable optimization improvements, and acceptable validation cost.

The Required Skills Change Rather Than Disappear

The paper argues that NeuroSPICE lowers the barrier to implementing emerging device and multiphysics models because users do not need to understand the numerical details of conventional SPICE.

That is plausible, particularly for researchers already comfortable with Python and machine-learning frameworks.

Yet organizations should not interpret it as a no-expertise modeling system.

NeuroSPICE introduces its own technical decisions:

• selecting the neural-network architecture;
• choosing time-sampling strategies;
• balancing DAE and initial-condition losses;
• selecting learning rates and training durations;
• diagnosing convergence failures;
• testing sensitivity to initialization;
• validating behavior outside the training configuration.

The FeRAM experiment itself illustrates this requirement. Its stronger nonlinearity required more training epochs and a smaller learning rate.

The workflow may become more accessible to one group of specialists while becoming less familiar to another. That can still be valuable. It is a change in organizational capability, not an elimination of engineering difficulty.

What the Paper Does Not Yet Test

NeuroSPICE is a compact feasibility study. The paper’s boundaries are unusually clear once its demonstrations are classified correctly.

It does not test:

• scaling to large transistor counts;
• industrial device-model libraries;
• quantified accuracy across broad operating conditions;
• process, voltage, and temperature corners;
• convergence rates across repeated training runs;
• sensitivity to architecture or loss weighting;
• stiff systems and abrupt discontinuities at production scale;
• noise, statistical variation, or event-heavy behavior;
• parameterized surrogate accuracy;
• inverse-design performance;
• gradient-based optimization outcomes;
• total engineering cost relative to established workflows.

The absence of these experiments does not undermine the central mechanism. It limits the maturity of the practical claim.

A business should therefore read NeuroSPICE as evidence that a different simulation architecture is possible—not as evidence that an EDA replacement is ready for procurement.

What Would Make NeuroSPICE Operationally Convincing

The next useful stage of evidence would not be another visually matching waveform from another small circuit.

More decisive tests would include:

1. A parameterized surrogate benchmark. Train one model across component or device parameters, then measure accuracy on unseen configurations.

2. A demonstrated optimization task. Use gradients from the surrogate to improve a circuit objective and compare the process with conventional search methods.

3. Scaling experiments. Measure training time, memory use, accuracy, and convergence as circuit size and model complexity increase.

4. Reliability analysis. Report variation across random initializations, loss weights, sampling schemes, and optimizer choices.

5. Workflow-cost comparison. Evaluate whether Python-level device prototyping actually reduces researcher time once model validation and neural-solver tuning are included.

6. Hybrid integration. Explore whether differentiable neural components can complement conventional SPICE rather than attempting to replace the complete solver.

The final option may prove especially practical. Industrial tools rarely disappear because a research prototype proposes a more elegant abstraction. They absorb useful capabilities around their edges.

A differentiable surrogate attached to an established simulation and verification workflow may reach practical value sooner than a fully neural simulator attempting to inherit every responsibility SPICE has accumulated since the 1970s.

A Simulator That Answers a Different Question

NeuroSPICE’s most important idea is simple to state and expensive to appreciate.

A conventional transient solver asks:

Given the current circuit state, what happens at the next time step?

NeuroSPICE asks:

What continuous waveform satisfies the circuit equations across the interval?

The first question has produced one of engineering’s most durable software categories. NeuroSPICE does not provide a reason to abandon it.

The second question produces a representation that is naturally compatible with automatic differentiation, Python-based physical models, and neural optimization. That compatibility may matter most in emerging-device research and design loops where the objective is not merely to observe one waveform, but to repeatedly reshape a system until the waveform becomes desirable.

For normal circuit simulation, NeuroSPICE is slower and less proven than the tools already available.

For differentiable circuit design, it offers something more valuable than a speed claim: a credible mechanism that can now be tested properly.

Cognaptus: Automate the Present, Incubate the Future.