From Loihi 2 to Your AWS Console

How Catalyst N2 brings full Loihi 2 feature parity to commodity cloud infrastructure and its impact on researchers, engineers, and anyone who cares about the future architecture of computation.

A researcher at a university with no Intel affiliation sits down with an AWS account and a Python environment. She writes a network definition, runs the compiler, and watches placement, routing tables, neuron programs, and synaptic memory layouts generate automatically. She deploys to an FPGA over PCIe. Spike readback comes back clean. The entire pipeline, from code to hardware execution and back, completes without a research agreement, without a waitlist, and without access to proprietary tooling. What she just ran on rented cloud hardware is architecturally equivalent to one of the most capable neuromorphic processors Intel has built.

That scenario is now possible because of Catalyst N2.

A Processor You Can Actually Use

Neuromorphic processors are often difficult for independent researchers to access. Intel’s Loihi systems are available only through a restricted research program. Catalyst N2 takes a different path by reproducing the architectural capabilities of Loihi 2 on FPGA hardware that anyone can rent by the hour.

A feature audit comparing the architecture against Loihi 2 identified 155 distinct capabilities. Catalyst N2 implements 152 of them directly; the remaining three depend on physical multi-chip links that cannot be exercised on a single FPGA board. The architecture, the software development kit, and the validation methodology together constitute something that has not previously existed. That is a professionally engineered, openly accessible neuromorphic computing platform validated against the full Loihi 2 feature set, including programmable neuron microcode and multi-trace learning.

From Fixed Circuits to Programmable Substrates

The central architectural move in Catalyst N2 is the replacement of a fixed neuron model with a programmable one. In the first generation, Catalyst N1, every neuron on every core executed exactly the same computation; The CUBA leaky integrate-and-fire model. That model is well understood, computationally clean, and entirely inflexible. Wanting a different neuron, one that burst, oscillated, adapted, or encoded information as a running error signal, required modifying the hardware itself.

N2 introduces a microcode engine that runs on each neuron at every timestep. The neuron is no longer a fixed-function unit. It executes a short program during the neuron update phase, using a sixteen-register file and a dedicated instruction set that determines exactly how that neuron integrates input, updates its internal state, and decides when to fire. Five neuron models ship with the SDK. The original CUBA leaky integrate-and-fire for backward compatibility, the Izhikevich model with its rich repertoire of spiking regimes, an adaptive leaky integrate-and-fire model that produces spike-frequency adaptation matching what neuroscientists observe in cortical pyramidal neurons, a sigma-delta neuron that transmits only changes in its input signal, and a resonate-and-fire neuron that responds selectively to inputs at its resonant frequency. A single core runs CUBA neurons in one layer alongside Izhikevich neurons in a recurrent population, with the compiler assigning microcode programs to each.

Each of these models coexists on the same physical core. A network can use CUBA neurons in sensory layers for computational speed, Izhikevich neurons in recurrent layers for temporal richness, and sigma-delta neurons at output interfaces for bandwidth-lean readout, all without any RTL modification. The compiler handles program allocation and deduplication. The researcher specifies the model per population. The hardware executes whatever program it is given.

Weight Precision as a Design Variable

In quantitative finance, the relationship between model precision and operational cost is something practitioners navigate constantly. Running a high-resolution Monte Carlo at tick frequency is expensive. Running a coarser approximation is cheaper and often good enough. The art is in knowing which precision level is appropriate for which decision, and building infrastructure that lets you tune that tradeoff in real time.

Catalyst N2 applies exactly this logic to synaptic weights. N1 stored all weights as 16-bit signed integers regardless of whether the network actually needed that resolution. N2 introduces variable-precision weight packing at five granularities: 1, 2, 4, 8, and 16 bits per weight, configurable per synapse group. A 1-bit weight achieves 16-to-1 compression relative to the 16-bit baseline. An 8-bit weight achieves 2-to-1 compression with a representable range sufficient for most quantization-aware trained networks.

The practical consequence is direct: a fully connected layer with 1,024 input and 1,024 output neurons at 4-bit precision fits into two neuromorphic cores; the same layer at 16-bit precision requires eight cores. A sparse 4,096-input layer at 2-bit weights fits three cores, while full connectivity there requires 12 cores at 16 bits. Per-synapse-group bit widths match how trading systems allocate resolution to high-value decisions only. N2 also exceeds Loihi 2 on the upper end of this range: Loihi 2 supports weights from 1 to 8 bits; Catalyst N2 supports 1 to 16 bits, providing headroom for networks requiring higher weight resolution than quantization-aware training can accommodate.

On-Chip Learning: Five Traces, Reward Traces, Homeostasis

A neuromorphic processor that can only run pre-trained networks is a neuromorphic inference accelerator. Catalyst N2 is something more: a system that can learn on-chip, in real time, through multiple interacting plasticity mechanisms. In spiking systems, learning rules depend on the timing relationships between spikes. Traces record recent activity so the learning engine can evaluate correlations across multiple timesteps.

Trace Architecture

Each neuron maintains five independent spike traces with separate four-bit decay shifts. Traces use seven-bit storage capped at 127 to match Loihi 2 register widths and avoid wraparound during decay. The additional traces beyond N1’s two enable triplet STDP, a learning rule that captures higher-order spike correlations that pair-based rules cannot represent. A guaranteed minimum step of one per timestep prevents stall at small positive values due to integer truncation.

Persistent Reward Traces

In N1, reward was a one-shot signal consumed immediately during the eligibility-to-weight conversion step. N2 adds a configurable reward trace with exponential decay. A reward injected at timestep 100 with a 50-timestep decay constant still contributes 37 percent to eligibility computation at timestep 150. When the time constant is set to zero, the behavior is identical to N1’s one-shot mode, preserving backward compatibility. When nonzero, the reward trace becomes a substrate for temporal credit assignment, the core computational problem of reinforcement learning.

Homeostatic Threshold Plasticity

Biological neural circuits maintain firing rate stability through homeostatic mechanisms that operate on slower timescales than synaptic plasticity. N2 implements epoch-based homeostatic threshold regulation: threshold adjusts by the ratio of observed spike count to target rate every 1,024 timesteps by default. A proportional error formulation replaced an earlier sign-based rule during a hardware fidelity audit. The sign-based rule produced oscillatory behavior near the target rate because a neuron firing one spike above target received the same correction magnitude as one firing ten times the target. Homeostasis operates independently of the synaptic learning engine, which is architecturally necessary: mixing mechanisms that operate on different timescales in the same microcode engine would create timing conflicts.

Simulation That Tells the Truth

The simulator clamps all state variables to 24-bit signed ranges matching FPGA register widths. The SRAM budget is enforced strictly: the compiler raises a descriptive error if any core exceeds 32,768 pool entries. Learning trace values are clamped to 127. Developers who want unbounded arithmetic for debugging must explicitly opt in. Networks with growing membrane potentials now saturate at plus or minus 8,388,607 in both simulator and FPGA, so training outcomes deploy without retraining.

The simulation uses the same fixed-point arithmetic and resource constraints as the FPGA backend.

The GPU simulator received a parallel treatment. N1 used standard float32 arithmetic for the learning path while the CPU simulator used integer arithmetic with stochastic rounding, producing different weight evolution trajectories. N2 closes this by implementing stochastic rounding in the GPU learning path, with per-core LFSR state that advances deterministically through the synapse scan. The CPU and GPU learning paths now produce statistically equivalent weight distributions. The test suite growth from 168 tests in N1 to 3,091 tests in N2, an 18.4-fold increase, reflects the same philosophy applied systematically.

FPGA Validation: What the Hardware Actually Does

The validation suite comprises 28 tests across seven categories: basic neuron behavior, synaptic connectivity, CUBA dynamics, network topologies, multi-core routing, scale and performance, and operational correctness. The validated instance runs 16 cores on the FPGA; the full architecture supports 128. All 28 tests passed. Nine additional RTL-level hardware tests generated over 163,000 spikes with zero mismatches.

Two engineering facts from validation apply to any FPGA neuromorphic system:

FPGAs power up with all BRAM at zero, so neurons fire continuously until host code sets thresholds to maximum. BRAM contents carry over between bitstream loads, so each test run silences prior neurons before new configuration. Both behaviors are consistent with production neuromorphic systems, where state persistence across configurations enables checkpoint-and-resume patterns, but the SDK must handle initialization explicitly.

The Signals Analogy

Fixed neuron models resemble hardcoded trading strategies that cannot adjust to new market patterns. Programmable microcode resembles a strategy engine where logic updates without infrastructure changes. Per-synapse-group bit widths match how trading systems allocate resolution to high-value decisions only.

The persistent reward trace maps directly to temporal credit assignment: knowing which earlier actions caused a later outcome. Variable-precision weight packing is the neuromorphic equivalent of the precision-cost allocation discipline practitioners already navigate. What makes all of this interesting from a systems perspective is not any individual feature but the combination: a programmable substrate, hardware-accurate simulation, validated on commodity infrastructure, with a test suite large enough to catch subtle interactions between features. That combination turns research code into deployable systems.

What Remains

The FPGA runs at 62.5 MHz versus Loihi 2’s expected ASIC rates. Core capacity holds 1,024 neurons, one-eighth of Loihi 2. PCIe throughput reaches 7,886 timesteps per second for 512 neurons; a DMA-based bulk transfer mechanism would improve this by an estimated factor of 10 to 50. Connected-network FPGA tests show spike counts three to fourteen times higher than simulator predictions, proportional to connection weight magnitude, pointing to a fixed exponent shift in the RTL’s synaptic accumulator that the compiler does not yet compensate for.

None of these are current gaps that block useful work. The Spiking Heidelberg Digits benchmark, preserved at 85.9% accuracy from N1, confirms that the extensive N2 modifications do not degrade the system’s ability to learn. These gaps shape the next steps: benchmarks designed to stress programmable neurons and multi-trace learning such as DVS gesture recognition and reinforcement learning tasks; deployment optimization via DMA bulk transfer and bitstream-level BRAM initialization; and ASIC exploration, where the architecture’s BRAM-dominated resource profile maps directly to custom SRAM macros.

Getting Started

SDK compiles Spiking Heidelberg Digits to FPGA in under 10 seconds. Researchers with AWS access run the 28 validation tests to verify their own networks deploy correctly. The complete RTL, SDK, and validation suite are under consideration for public release.

What matters here is not a single feature but the entire stack. Programmable neurons, multi-trace learning, hardware-faithful simulation, and FPGA validation on infrastructure available to any researcher. That combination turns neuromorphic architectures from specialized lab equipment into systems that can be built, tested, and shared in the same way as other cloud-based computing platforms.


Based on: Barnes, H.A.S. “Catalyst N2: Full Loihi 2 Feature Parity in an Open Neuromorphic Processor with Programmable Neuron Microcode and Cloud FPGA Validation.” University of Aberdeen, 2025.

Related Articles

PHP Code Snippets Powered By : XYZScripts.com
★

Track This Company

Create a free account to add companies to your watchlist and get notified when patents, funding, or key developments change.