The first shared compiler path for spiking networks, and the substrate it leaves outside

What the work claims

Garcia Gener and Rollon de Pinedo start from a gap the spiking-network ecosystem has learned to live with. Training frameworks have multiplied (snnTorch, Lava, Norse, Nengo, Rockpool, Sinabs), and the Neuromorphic Intermediate Representation, NIR, solved the exchange problem among them: a small, framework-neutral vocabulary of neuron and synapse primitives into which any of them can export a trained model.¹ But NIR deliberately stops at description. As the authors put it, it provides a description of a network, not a path to running one. Every backend still hand-writes its own inference loops, quantization, and runtime.

Their claim is architectural: spiking networks deserve a proper compiler intermediate representation, and MLIR, the extensible compiler infrastructure from the LLVM project, is the right home for it.³ The artifact backing the claim is a six-operation MLIR dialect covering linear synapses, rescaling, and the four behaviors of the current-based leaky integrate-and-fire family, plus a Python front end that reads any NIR file and a lowering pass that hands the result to the standard MLIR and LLVM toolchain, ending in dependency-free C11.¹

This is an infrastructure and position paper, not a benchmark paper, and it should be weighed as one. The evaluation is validation-oriented: two small example networks, exported from two different frameworks, compiled and checked for fidelity, portability, and quantization cost. The scope is explicitly narrow: feedforward, fully connected, linear-chain networks, batch size one, uniform parameters within each layer, one CPU backend.

How it works

An intermediate representation is the data structure a compiler transforms: a program description precise enough to verify and rewrite mechanically. MLIR organizes such representations into dialects, domain-specific operation sets that are progressively lowered, rewrite by rewrite, toward machine code. The snn dialect makes a spiking layer a first-class compiler object: a 256-neuron CUBA-LIF layer is one operation carrying its decay constants and threshold as attributes, with its synaptic-current and membrane-voltage buffers updated in place each timestep.

Two design decisions do most of the work. First, type polymorphism: the same operation runs on float32 data for simulation and on quantized integer data for deployment, selecting between two attribute sets by operand type, so the reference semantics and the deployed semantics cannot drift apart. Second, automatic scale alignment. Weights quantize to int8 with a per-layer power-of-two exponent; neuron dynamics run in Q12 fixed point, meaning values are stored as integers scaled by 2 to the 12th. Those exponents almost never match, and feeding one stage into the next unaligned silently corrupts the dynamics. The front end inserts a rescale operation on every synapse-to-neuron edge that shifts by exactly the difference of the two exponents, turning a notorious silent bug in hand-written quantized inference into something guaranteed correct by construction.¹

The evaluation bears the design out at small scale. In float mode the compiled binaries are bit-exact against the source frameworks on both test networks. In int8, fidelity drops to 99.585 percent of output cells on one network and 92.0 percent on the other, but the integer build is deterministic across architectures: an x86 laptop and a bare-metal RISC-V core produce identical spike trains, mismatch for mismatch. The compiled binary runs its per-timestep kernel in a fixed 12.6 KB of code and beats running the same network inside its Python framework by factors of 157 to 266, a comparison the authors are careful to frame as removing interpreter overhead rather than as a performance claim.¹

Where a skeptic should push

The load-bearing assumption is that a shared compiler layer is what the ecosystem is missing, rather than what vendor toolchains already provide. Chip-specific compilers exist; what snn-mlir adds is the framework-neutral, target-neutral middle. Whether that middle attracts backends is a sociology question the paper cannot answer, and the authors' own most strategic item of future work, a NIR-level quantization standard, concedes that the hard part is agreement, not code.

The evaluation is thin in ways the authors mostly flag. Two networks totaling a few hundred output spikes is a smoke test, not a characterization; the 92.0 percent int8 fidelity on the snnTorch network shows quantization error is network-dependent and can be material, and no accuracy-on-task numbers are reported, only spike-level agreement. The speedup baseline, a Python interpreter stepping a small network, is honest about what it is but says nothing about how the generated C compares with hand-written inference loops, which is the comparison a skeptical engineer actually wants.

Most consequentially for readers of this site: the supported topology class excludes recurrence. Liquid state machines and every reservoir-flavored architecture, the network class closest to how physical and biological substrates actually compute, sit outside the current linear-chain walker. The authors name recurrent support as future work; until it lands, the toolchain covers the network class furthest from wetware.

Compilation as the boundary of biocomputing

NIR was designed to be broad. It describes both discrete-time digital and continuous-time analog neuron models, parameterized by physical quantities such as membrane time constants, and its authors positioned it as a unified instruction set for brain-inspired computing across substrates.² There is no formal reason a NIR graph could not specify a computation intended for living neural tissue. The gap this paper names, a description of a network but no path to running one, is therefore the organoid intelligence field's central unsolved problem stated in compiler vocabulary. For silicon CPUs, closing that gap took two people, six operations, and one lowering pass. For tissue, nobody has stated what closing it would even mean.

The non-obvious lesson is in what the compiler quietly relies on. Every stage of snn-mlir assumes parameters are attributes you set: uniform per-layer decay constants, exact fixed-point arithmetic, state buffers that can be zeroed, verifier-checked types, deterministic execution. A cultured neural network inverts every assumption. Its parameters are heterogeneous, developmentally drifting quantities you can at best estimate from recordings; its state cannot be written, checkpointed, or reset; its dynamics are stochastic. The consequence is stronger than "a tissue backend would be hard": under this architecture a tissue backend is a category error, because the contract every upstream pass depends on, that lowering preserves exact semantics, has no tissue analogue. A compilation path for living substrates would have to return something else entirely, plausibly a stimulation and training protocol plus a statistical conformance suite, with acceptance defined over spike-train distributions rather than bit equality. Naming that contract is, in our view, a publishable research agenda this paper hands to the OI field unintentionally.

The opportunity inside the same observation: determinism makes a perfect control. The C11 path gives any OI lab a bit-faithful, dependency-free reference implementation of the exact NIR graph it is trying to coax a culture toward, runnable on a microcontroller next to the incubator. Tissue-versus-silicon comparisons in the literature routinely founder on mismatched network specifications; a shared NIR source with a compiled deterministic reference would remove that excuse. The rescale mechanism carries a second, smaller lesson, offered here strictly as an algorithmic-level analogy: stimulus chains in tissue experiments are full of silent gain mismatches between DAC, electrode, and evoked response, and snn-mlir shows the value of making every interface's scale explicit and machine-checked rather than tuned by hand.

The threat is standardization gravity. Toolchains define fields: what the IR can express and the verifier can check becomes, operationally, what the field means by a neural computation. As NIR-to-hardware paths harden around quantized, clocked, deterministic semantics, benchmarks, procurement, and training pipelines will follow, and living substrates will fail every conformance check, not because they compute less but because they cannot be object code. The properties tissue actually offers, intrinsic plasticity, self-organization, femtojoule-scale synaptic events, have no vocabulary in this IR. If the OI field does not articulate its own conformance criteria, statistical equivalence, task-level equivalence, learning-efficiency metrics, before the deterministic definition ossifies into standards, it will spend the next decade being measured by criteria it structurally cannot meet.

The bottom line

Established: snn-mlir does what it says on its two test networks. Float compilation is bit-exact, int8 compilation is deterministic across two instruction sets, and the whole path from NIR to embedded C exists as auditable open source. Position, not yet established: that MLIR becomes the shared middle layer of the neuromorphic ecosystem; that depends on adoption the paper cannot demonstrate.

For organoid intelligence the paper contributes no experiment and claims nothing; its value is as a mirror. It shows concretely what a deployment path is, and thereby how far computing on living tissue stands from having one. Watch for three things: recurrent and liquid-state-machine support, which would bring the toolchain into contact with reservoir-style physical computing; a community quantization standard at the NIR level; and any first attempt, from either community, to define conformance for substrates that cannot promise the same answer twice. The first two are engineering. The third is where organoid computing either gets a seat at the standards table or gets defined out of the field.