For decades, neuromorphic chips—hardware inspired by the brain’s event-driven, energy-efficient computing—languished in labs. Their promise was held back not by hardware limitations, but by a persistent software gap: programming them required neuroscience-level expertise, and each new chip came with its own bespoke programming model. That began to change five years ago.
Why the Software Bottleneck Persisted
For nearly thirty years, neuromorphic computing has been a field of immense promise and profound frustration. Visionaries like Carver Mead at Caltech began fabricating silicon retinas and cochleas in the late 1980s, demonstrating that hardware could mimic the brain’s energy-efficient, event-driven processing. Yet, despite decades of hardware advances—from IBM’s TrueNorth to Intel’s Loihi processors—the field remained largely confined to academic labs and specialized research groups.
The reason was not a failure of hardware, but a persistent, debilitating software bottleneck. This created a classic chicken-and-egg problem: without accessible software, developers couldn’t build applications, and without applications, there was little incentive to fund the development of a robust software ecosystem.
The Fundamental Paradigm Mismatch
The core challenge was a fundamental paradigm mismatch. Conventional computers, built on the von Neumann architecture, process instructions sequentially. Their programming languages, compilers, and development tools are all optimized for this model.
Neuromorphic chips, however, are massively parallel, asynchronous, and communicate through “spikes”—discrete events in time. Traditional programming paradigms simply could not express the computational logic of these brain-inspired systems. Early attempts to program them required deep, interdisciplinary expertise in neuroscience, electrical engineering, and computer science—a skillset vanishingly rare.
Developers were often forced to work at the level of individual silicon neurons. This process was as tedious and impractical as programming a modern supercomputer by flipping individual switches. The result was a thirty-year gap where hardware capabilities vastly outpaced the software needed to control them.
The Non-Differentiable Problem
The roadblocks were not just matters of convenience—they were fundamental technical hurdles. The primary obstacle was the nature of Spiking Neural Networks (SNNs), the algorithms that run on neuromorphic hardware.
The learning process in modern AI relies on backpropagation, a method that requires mathematical functions to be “differentiable”—meaning they have smooth gradients that can guide optimization. Spikes, being all-or-nothing events, are not differentiable. This made it nearly impossible to apply the powerful gradient-based training techniques that fueled the deep learning revolution.1
Furthermore, the field lacked standardized APIs and development environments. Each new neuromorphic chip came with its own hardware-specific programming model, preventing portability and forcing developers to relearn their craft with each new generation of hardware. The academic focus on novel hardware architectures often left software as an afterthought, perpetuating a cycle of innovation without adoption.
Breakthroughs That Broke the Bottleneck
In the last five years, this landscape has transformed dramatically. A confluence of breakthroughs in training algorithms, the emergence of production-ready frameworks, and a collaborative push toward standardization has finally broken the software bottleneck.
Neuromorphic programming is transitioning from a niche academic pursuit to a viable engineering discipline, accessible to a much broader community of developers. This shift represents the critical enabling factor that could move neuromorphic computing from the lab into real-world applications. Next, we examine the algorithmic breakthroughs that finally made training SNNs viable.
The Surrogate Gradient Revolution
The most significant breakthrough came in solving the non-differentiable spike problem. Researchers developed “surrogate gradient” methods—smooth approximations that substitute the problematic spike function with a differentiable alternative during the training phase.2
This clever workaround allowed the powerful machinery of gradient-based optimization to be applied directly to SNNs for the first time. The impact was immediate and profound, enabling SNNs to be trained to achieve performance competitive with traditional artificial neural networks on complex tasks, with reported accuracies exceeding 90% in cases like CIFAR-100 image classification and PS-MNIST pattern recognition.
More recently, mathematically exact approaches have emerged. EventProp, developed in 2020, computes exact gradients for event-based learning without approximations.3 Similarly, Smooth Exact Gradient Descent, published in early 2025, offers a framework for precise gradient computation in spiking networks.4 These exact methods further close the performance gap between surrogate approximations and theoretically optimal training.
This evolution from conversion-based methods—turning a trained traditional network into a spiking one—to direct training has been the key to unlocking the full potential of SNNs. Now we turn to how these algorithmic advances were embedded in usable software frameworks.
Production-Ready Frameworks Emerge
While algorithmic breakthroughs were crucial, they needed to be embedded in stable, usable software. This is where Intel’s Lava framework has become a pivotal development.
Released as an open-source project, Lava was designed to bridge the gap between academic research and industrial application.5 It provides a structured, modular framework that allows developers to prototype neuromorphic algorithms on conventional CPUs and then deploy them seamlessly to neuromorphic hardware like the Loihi and Loihi 2 chips.
This workflow mirrors the evolution of deep learning, where frameworks like TensorFlow and PyTorch abstracted away the low-level complexities of GPU programming, enabling millions of developers to build sophisticated models. Lava aims to do the same for neuromorphic computing, providing a stable, well-documented platform that hides hardware complexity while preserving the benefits of brain-inspired computation.
Developer-Friendly Abstractions
The path to mainstream adoption is paved with good abstractions. For a technology to scale, it must become accessible to developers who are not experts in its underlying mechanics. The latest generation of neuromorphic software tools focuses on precisely this, creating intuitive, high-level interfaces that integrate with the existing Python-based machine learning ecosystem.
Intel Lava: Write Once, Run Anywhere
The architecture of Lava is a masterclass in pragmatic design. It enables a write-once, run-anywhere-efficiently workflow through its modular, event-based architecture and hardware-targeting compiler system.
A developer can write their algorithm using Lava’s APIs and test it on their laptop. That same code can then be executed on high-performance multi-core CPUs, and ultimately, on Loihi 2 hardware without modification. This is enabled by a compiler and runtime system that translates a high-level process description into the specific machine code for the chosen hardware backend.
Loihi 2, Intel’s second-generation neuromorphic processor, offers up to 12x improvements in specific performance metrics over its predecessor, with some benchmarks showing even higher gains for particular algorithms and workloads.5 By providing clear API design principles and extensive documentation, Lava is helping to build a community of practice around a standardized toolset, attracting developers from outside the traditional neuromorphic research sphere.
NIR: The Universal Translator
Perhaps the most powerful catalyst for interoperability is the Neuromorphic Intermediate Representation (NIR)—to neuromorphic computing what ONNX is to deep learning or LLVM is to compilers.
Developed by a consortium of academic and industry researchers, NIR is a standardized, declarative way to describe the computational graph of a neural network.6 It defines a common set of computational primitives that can be used by different neuromorphic simulators and hardware platforms, abstracting continuous-time dynamics and discrete events into portable representations.
NIR decouples software from hardware completely. A developer can design and train a network using a high-level Python framework like snnTorch, export it to NIR, and then deploy it on any supported hardware, from SynSense’s DYNAP-SE2 to Intel’s Loihi 2. Currently, NIR is supported by 8 simulators and 5 hardware platforms, creating a truly cross-platform ecosystem for the first time.7
This “write once, run anywhere” capability is critical for preventing vendor lock-in and fostering a collaborative, competitive software market. Next, we examine how this standardization effort is professionalizing the entire development ecosystem.
From Research to Production
The final piece of the puzzle is the creation of a robust ecosystem that supports the entire lifecycle of development, from research to production. This involves building translation layers that make it easy to implement ideas from academic papers in production code.
It requires extensive documentation, tutorials, and educational programs to train a new generation of neuromorphic developers. The Intel Neuromorphic Research Community (INRC) now provides hardware access and collaborative research opportunities, lowering barriers to entry for academic and industrial researchers alike.
Furthermore, standardized benchmarking frameworks like NeuroBench are emerging to allow for fair, apples-to-apples comparisons of different algorithms and hardware platforms.8 This professionalization of the development process is a clear sign of a field reaching maturity.
The Path to Mainstream Adoption
The convergence of these software breakthroughs has set the stage for the mainstream adoption of neuromorphic computing. The growth patterns of the developer ecosystem, from GitHub activity to venture capital investment, mirror the early days of other transformative technologies. While significant hurdles remain, the path forward is clearer than ever before.
Learning from Technology History
History provides a useful map for the road ahead. The transition from MS-DOS to Windows in personal computing demonstrates how powerful graphical user interfaces can abstract away underlying complexity and unleash mass adoption. The standardization of graphics programming through OpenGL and DirectX created a stable platform for the video game industry to flourish. More recently, the rise of cloud computing was enabled by infrastructure-as-a-service platforms that hid the immense complexity of managing data centers.
In each case, the winning formula was the same: create powerful, intuitive software abstractions that allow developers to focus on building applications, not on managing hardware. Neuromorphic computing is now in the midst of its own “Windows moment,” with frameworks like Lava and standards like NIR providing the essential abstractions needed for widespread adoption.
Intel’s Hala Point system, featuring 1,152 Loihi 2 processors, demonstrates what’s now possible at neuromorphic scale—supporting neural networks with over 1 billion parameters while maintaining the energy efficiency advantages that make neuromorphic computing compelling for edge applications.
Real-World Applications Emerge
With the software bottleneck breaking, neuromorphic computing is poised to find its place in application areas where its unique advantages—low power consumption, low latency, and high efficiency for event-based data—are most critical.
This includes edge AI applications in robotics, autonomous vehicles, and IoT devices where energy efficiency is a primary constraint. The economic drivers are powerful; as the energy costs of running large-scale AI models in data centers continue to spiral, the demand for energy-efficient alternatives will only grow.
While technical hurdles remain—such as the need for more mature development tools and broader hardware access—the fundamental software challenges that blocked progress for three decades have finally been solved. The hardware-software revolution is here, and it is finally possible to program the future of computing.
References
- Neftci, E. O., Mostafa, H., & Zenke, F. (2019). Surrogate Gradient Learning in Spiking Neural Networks. IEEE Signal Processing Magazine, 36(6), 51-63. https://doi.org/10.1109/MSP.2019.2931595
- Eshraghian, J. K., Ward, M., Neftci, E., et al. (2023). Training Spiking Neural Networks with Surrogate Gradients: A Survey and Perspective. ArXiv. https://arxiv.org/abs/2308.08040
- Wunderlich, T., & Pehle, C. (2020). Event-based backpropagation can compute exact gradients for spiking neural networks. Scientific Reports, 11, 12829. https://arxiv.org/abs/2009.08378
- Klos, C., Kneißl, M., & Schemmel, J. (2025). Smooth Exact Gradient Descent Learning in Spiking Neural Networks. Physical Review Letters, 134, 027301. https://link.aps.org/doi/10.1103/PhysRevLett.134.027301
- Intel Corporation. (2024). Lava Software Framework for Neuromorphic Computing. Intel Neuromorphic Research. Retrieved from https://lava-nc.org/
- Bauer, F., Billaudelle, S., Cramer, B., et al. (2024). Neuromorphic intermediate representation: A unified instruction set for interoperable brain-inspired computing. Nature Communications, 15(1), 52259. https://doi.org/10.1038/s41467-024-52259-9
- Neuromorphic Intermediate Representation. (2024). NIR: Cross-platform neuromorphic computing. GitHub Repository. Retrieved from https://github.com/neuromorphs/NIR
- Soller, M., Moraitis, T., et al. (2024). The NeuroBench Framework: Benchmarking Neuromorphic Computing Algorithms and Systems. Frontiers in Neuroscience, 18, 1089. https://doi.org/10.3389/fnins.2024.1089