August 14, 2026 · 22 min read

NeuroCUDA vs SpikingJelly

A 2026 comparison of two PyTorch-adjacent SNN tools that share spikes and CUDA, then diverge at the starting artifact: a trained ANN checkpoint versus a blank spiking network you train from scratch.

NeuroCUDA vs SpikingJelly is a job mismatch, not a winner list. NeuroCUDA is a conversion compiler: pip install neurocuda, then snn, meta = neurocuda.convert(model, calib_loader). Source: https://github.com/Krishnav1/neurocuda. SpikingJelly trains SNNs from scratch with surrogate gradients. Pick conversion for a trained checkpoint; pick SpikingJelly to design spikes from random init.

This page vs nearby pages: this URL is NeuroCUDA vs SpikingJelly only. snnTorch vs NeuroCUDA is a different training library and is not rewritten here. ANN-to-SNN tools compared is the multi-tool roundup. SNN framework comparison covers Rockpool, Sinabs, Norse, Brian2, and Nengo. N-MNIST SNN conversion is the event-dataset HowTo. Google should index this page for the SpikingJelly pairwise query.

Search results for neurocuda vs spikingjelly often flatten both names into one bucket labeled "PyTorch SNN library." That bucket is wrong. SpikingJelly is built so you can write spiking layers, loop over timesteps, apply surrogate gradients, and train a network that was spiking from epoch one. NeuroCUDA is built so you can keep a conventional ReLU network you already trained, calibrate it, replace activations with integrate-and-fire neurons, and fine-tune the result. The first tool answers "how do I train spikes." The second answers "how do I convert this checkpoint."

QuantaraCore Technologies LLP builds NeuroCUDA and documents SpikingJelly fairly because picking the wrong tool costs weeks. This article is the pairwise decision page: jobs, APIs, CUDA meaning, ResNet handling, event data, backends, and honest limits. Author: Krishna Santosh Varma. Source for NeuroCUDA: github.com/Krishnav1/neurocuda. Product hub: /neurocuda. Technical report: /neurocuda/paper.pdf.

NeuroCUDA vs SpikingJelly: two different jobs

The useful way to read neurocuda vs spikingjelly is to ask what you already have on disk. If the answer is a trained torch.nn.Module with ReLU activations, you do not want to throw away GPU hours and rebuild every layer as a spiking module. If the answer is a research question about neuron models, surrogate functions, or training a spiking architecture from random weights, you do not want a converter that assumes the hard ANN training is finished.

That table is the entire comparison if you already know your starting artifact. The rest of this page exists because forums still treat the two names as interchangeable CUDA SNN stacks. They share PyTorch and they share the word "spike." They do not share a pipeline.

What SpikingJelly actually is

SpikingJelly is a PyTorch SNN training library. You define neurons (LIF, IF, and related variants), wrap them in sequential or residual modules, and train with surrogate gradients so the non-differentiable spike can still receive a gradient. The library emphasizes computational efficiency: CUDA-accelerated neuron simulation, cupy paths, and multi-step modules that keep the timestep loop inside fused kernels instead of a slow Python for t in range(T) around every layer.

A typical SpikingJelly workflow looks like architecture design, not conversion. You choose a neuron, a surrogate (atan, sigmoid, or a custom function), a timestep count, a reset mode, and a loss that reads either spike counts or membrane potentials at the last layer. You then train for tens or hundreds of epochs on GPU, watching accuracy climb from random initialization the same way you would train a CNN, except every forward pass is a sequence of binary events.

import torch
import torch.nn as nn
from spikingjelly.activation_based import neuron, functional, layer, surrogate

class SJNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = layer.Conv2d(2, 32, kernel_size=3, padding=1)
        self.bn = layer.BatchNorm2d(32)
        self.lif = neuron.LIFNode(surrogate_function=surrogate.ATan())
        self.pool = layer.AdaptiveAvgPool2d(1)
        self.fc = layer.Linear(32, 10)

    def forward(self, x):
        # x: [N, T, C, H, W] event tensor, not a CIFAR RGB frame
        x = self.lif(self.bn(self.conv(x)))
        x = self.pool(x).flatten(1)
        return self.fc(x)

net = SJNet()
functional.reset_net(net)  # required between samples in many SJ setups

That sketch is teaching code, not a claim that one tutorial net matches a published leaderboard. The point is the job: you own the spiking architecture. SpikingJelly will not ingest a ResNet-18 ANN checkpoint, fold BatchNorm, calibrate ReLU thresholds, and emit a validated SNN. If that is what you need, you are in NeuroCUDA territory.

What NeuroCUDA actually is

NeuroCUDA is a conversion compiler. The hard ANN training is assumed done. You load a ReLU torch.nn.Module, pass a calibration DataLoader that looks like deployment data, and call convert. Inside that call, QCFS (quantization-clip-floor-shift) replaces ReLU with a calibrated, still-graded activation; BatchNorm folds into preceding conv or linear weights; integrate-and-fire neurons replace the calibrated activations; BPTT fine-tuning with an atan surrogate recovers accuracy that a naive ReLU-to-spike swap would destroy.

import neurocuda

# pip install neurocuda
# source: https://github.com/Krishnav1/neurocuda
snn, meta = neurocuda.convert(model, calib_loader)
neurocuda.compile(snn, target="gpu")
acc = neurocuda.evaluate(snn, test_loader)
sparsity = neurocuda.measure_sparsity(snn, test_loader)
neurocuda.to_nir(snn, "converted.nir")

Published, multi-seed numbers live in the technical report. On a 3-layer CNN for N-MNIST (event-based, not CIFAR images): SNN 99.88% ± 0.02% versus ANN 99.70%. On ResNet-18 / CIFAR-10 at T=32: SNN 94.61% ± 0.14% versus ANN 95.56% ± 0.11%. GPU versus CPU spike match: 0 deviations across 256,000 comparisons. NIR residual round-trip on ResNet-18: 0.000000 max absolute difference. Those figures are conversion evidence, not from-scratch SNN training evidence. Do not paste them into a SpikingJelly paper as if the training library produced them.

Head-to-head feature table

Read the CUDA row twice. SpikingJelly's CUDA story is "make training large SNNs fast." NeuroCUDA's CUDA story is "run the converted network on GPU and prove it matches CPU." Both are neuromorphic CUDA in the loose sense used by the neuromorphic CUDA field guide. They are not the same kernel generator, and neither is NVIDIA cuDNN.

Workflows compared in code

SpikingJelly: train from scratch

You allocate a spiking net, reset state between samples, accumulate loss over T steps, and step an optimizer. Data is often already in a timestep-major layout. For event cameras that can be natural. For CIFAR RGB it means encoding pixels into spikes first, which is a separate design choice and a common source of "why is my accuracy 20%" bugs.

# Conceptual SpikingJelly training loop
for images, labels in train_loader:
    functional.reset_net(net)
    optimizer.zero_grad()
    out = net(images)          # images already [N, T, ...]
    loss = criterion(out, labels)
    loss.backward()
    optimizer.step()

NeuroCUDA: convert a trained ANN

You keep the ANN training loop you already trust. Conversion is a compiler pass plus a short BPTT fine-tune, not a from-scratch run to 200 epochs of spiking layers. Calibration data must match test preprocessing. Then you compile a backend and evaluate against the same test set you used for the ANN baseline.

import torch, neurocuda

model.eval()
snn, meta = neurocuda.convert(model, calib_loader, timesteps=32)
neurocuda.compile(snn, target="gpu")
ann_acc = neurocuda.evaluate(model, test_loader)
snn_acc = neurocuda.evaluate(snn, test_loader)
print(ann_acc, snn_acc, meta)

The meta object is conversion metadata (thresholds, timestep settings, calibration notes). Keep it next to the checkpoint so a later engineer can reproduce the run. For a command-level reproduction path see reproduce NeuroCUDA results. For a free GPU notebook path see NeuroCUDA on Google Colab.

When SpikingJelly wins

• You do not have a trained ANN, or the ANN is a throwaway baseline you would retrain anyway.
• The architecture is spiking-native: custom LIF parameters, recurrent SNN cells, or research into surrogate functions.
• You need fused CUDA neuron kernels because the timestep loop is the bottleneck, not conversion accuracy.
• You are teaching or learning membrane dynamics, reset modes, and spike-count losses.
• Event-camera research where the network should be spikes all the way through training, not an ANN trained on voxel grids then converted.

Those are real jobs. NeuroCUDA will not replace a research simulator or a from-scratch training library. Claiming otherwise would be the same category error this page exists to stop.

When NeuroCUDA wins

• You have a production PyTorch perception model (robotics, edge vision, event-camera ANN trained on accumulated frames or voxel grids).
• Stakeholders need published conversion gaps, not a new from-scratch SNN paper.
• Residual architectures must convert without manual skip-connection surgery. See ResNet-18 SNN conversion tutorial for the CIFAR path, which is a different tutorial from N-MNIST.
• You need NIR export with a verified residual executor. See export PyTorch to NIR.
• You want GPU today, CPU CI parity, and a Loihi 2 equation simulator without Intel Lava. Loihi 2 remains a simulator. Physical Loihi silicon is not claimed.

Install remains one line: pip install neurocuda. Optional extras: pip install neurocuda[all]. Method explainer for the calibration stage: QCFS ANN to SNN. If thresholds stall during conversion, that is a debugging article (QCFS threshold not learning), not a reason to switch to SpikingJelly.

Accuracy: do not mix leaderboards

Comparing a SpikingJelly MNIST tutorial to NeuroCUDA ResNet-18 CIFAR numbers is not a comparison. One is from-scratch training on a task the author chose. The other is a conversion gap versus a fixed ANN baseline, multi-seed, full test set. The fair neurocuda vs spikingjelly question is workflow fit.

N-MNIST is event-based neuromorphic MNIST, recorded with a DVS camera. It is not CIFAR-10 RGB. Mixing those datasets is the second most common error after mixing the tools. Dedicated event conversion write-up: N-MNIST SNN conversion. Event-camera ROS2 context: event camera DVS ROS2.

Residual networks and skip connections

Skip connections are where converters fail silently. Two branches must sum at the merge node in the same order the ANN did. SpikingJelly can implement residual SNNs if you write them. That is architecture work. NeuroCUDA's contribution is narrower: convert a trained ResNet-18, keep residual adds, export NIR, and verify bit-exact round-trip on that residual graph. If your question is "can I train a residual SNN from scratch with CUDA kernels," SpikingJelly is in play. If your question is "can I convert this ResNet-18.pth," NeuroCUDA is the direct path.

Backends and hardware honesty

SpikingJelly targets GPU and CPU training and inference in PyTorch. That is appropriate for a training library. NeuroCUDA labels backends as follows, and this page will not inflate them:

• NVIDIA GPU: conversion and inference backend with published accuracy.
• CPU: bit-exact to GPU in the published spike check. Useful for CI.
• Loihi 2: IF-neuron simulator checked against published equations. Not Loihi silicon. Not Lava.
• SpiNNaker-1: physical silicon smoke test on EBRAINS (jobs documented on the silicon post). That smoke test is not N-MNIST accuracy on chip and is not a SpikingJelly backend.
• NIR: portable graph, not a chip.

If a vendor page tells you SpikingJelly "deploys to Loihi" or NeuroCUDA "matches SpiNNaker ResNet accuracy," demand the job ID and the test set. Until then, use the labels above. Broader compiler landscape: ANN to SNN conversion tools compared.

Can you use both?

Yes. A sane hybrid looks like this:

1. Prototype neuron behavior, reset semantics, and timestep counts in SpikingJelly on a small event or MNIST-scale task.
2. Train the production ANN in vanilla PyTorch so you can use standard augmentations, AMP, and the rest of your ML stack.
3. Convert with NeuroCUDA: snn, meta = neurocuda.convert(model, calib_loader).
4. Validate on GPU, measure sparsity, export NIR if you need a vendor-neutral graph.

That sequence respects each tool. It also avoids the failure mode where a team spends a quarter rewriting ResNet in spiking layers because a listicle said SpikingJelly is "the CUDA SNN framework" and never mentioned conversion.

Common mistakes when people search this pair

• Treating them as snnTorch clones of each other. snnTorch is a third library. Pairwise page: snnTorch vs NeuroCUDA. This page stays on SpikingJelly.
• Expecting convert() in SpikingJelly. You will write neurons and train. That is the product.
• Expecting from-scratch SNN research APIs in NeuroCUDA. You will convert. Custom plasticity belongs elsewhere.
• Pasting CIFAR numbers onto N-MNIST or the reverse. Different datasets, different tutorials.
• Calling Loihi 2 "on chip" because a simulator compiled. Simulator only.
• Calling SpiNNaker smoke tests an N-MNIST result. They are not.

Decision table you can hand to a teammate

GeNN and Brian2 are simulators, not SNN training libraries in the SpikingJelly sense and not converters in the NeuroCUDA sense. If that is your search, go to NeuroCUDA vs GeNN vs Brian2 instead of this page.

Frequently asked questions

Start now: pip install neurocuda · Product page · PDF report · GitHub