Stochastic & Neuromorphic Computing  /  Learn  /  Neuron models

Neuron models
the dynamics, rendered & playable

A neuron model is a small set of differential (or difference) equations with a threshold. SC-NeuroCore carries a large, literature-transcribed library of them. The traces below are rendered from the library itself — not sketched — then you can drive an Izhikevich neuron live, and see how one equation runs across five languages.

A gallery of dynamics

Eight models spanning the families — integrate-and-fire, biophysical conductance, reduced oscillators, bursters and discrete maps. Every curve is the membrane variable produced by running that model in SC-NeuroCore under a constant input; the vertical ticks are its spikes.

Each trace is one state variable over time under a fixed input current, produced by the bundled model schema. Absolute scales differ between models (millivolts for biophysical cells, dimensionless for maps), so each panel is auto-scaled to its own range.

Play — the Izhikevich neuron

Izhikevich's model is famous for a reason: two equations and four parameters $(a,b,c,d)$ reproduce twenty cortical firing patterns. Pick a preset or drag the parameters and watch the membrane potential respond in real time.

$$\frac{dv}{dt}=0.04v^2+5v+140-u+I, \quad \frac{du}{dt}=a(bv-u), \quad v\ge 30 \Rightarrow \begin{cases}v\leftarrow c\\ u\leftarrow u+d\end{cases}$$
Live — membrane potential $v(t)$ and spikes
rate —

This one runs the exact Izhikevich integration in your browser. Regular spiking, bursting, chattering, fast spiking — all the same two equations, only the four constants change.

How the models run — one equation, many backends

A model in SC-NeuroCore is not tied to one implementation. Its dynamics are declared once — as equations in a schema — and the same kernel is provided across a polyglot compute chain, so you prototype in Python and make it fast without rewriting the science.

Equation schema
dv/dt = f(v,I)
→
Python
reference & readability
+
Rust · Julia · Go · Mojo
accelerated kernels
+
GPU · MPI
scale out
→
Verilog / FPGA
the same dynamics

The gallery traces above came out of the Python reference path. The accelerated backends — Rust, Julia, Go and Mojo — implement the same kernels for throughput, chosen per workload, with a GPU path (CuPy/JAX) and MPI for distributed simulation. And because the model is declared as equations, the same definition also lowers to fixed-point Verilog for hardware.

Deeper: why four accelerated languages, not one
Each backend earns its place on a different axis: Rust gives memory-safe SIMD kernels with a mature FFI; Mojo targets Python-syntax kernels that compile to native speed; Julia brings a scientific-computing ecosystem and fast array maths; Go offers simple, well-behaved concurrency for network-level parallelism. A model's dynamics are written once and dispatched to whichever backend fits — the numerical contract is held bit-true across them, and validated against the model's published source traces before it ships, so switching backend changes the speed, not the science. This polyglot layer is what lets the same neuron be a readable Python object, a fast production kernel, and a proven FPGA module.
The full neuron atlas →Equation to silicon →
Where to next
Spiking networks — the theory Browse all models Run them in a notebook Back to Learn

Gallery traces are authentic SC-NeuroCore output under a fixed input current, captured once and embedded here. The Izhikevich panel runs the exact model live in your browser; both illustrate dynamics rather than serving as the bit-true fixed-point datapath used for hardware generation.