Marple: Scalable Spike Sorting for Untethered Brain-Machine Interfacing

Eugene Sha, Andy Wei Liu, Kareem Ibrahim, Mostafa Mahmoud, Christina Giannoula, Ameer Abdelhadi and 1 other

A brain implant records electrical signals from thousands of tiny electrodes, and spike sorting is the job of deciding which neuron fired and when — accurate software sorters need a power-hungry GPU and work on recordings after the fact, while small hardware sorters handle at most 128 electrodes; Marple is a hardware pipeline that finds the memory used to store neuron templates is the true bottleneck, shrinks it 8 to 11 times, and is projected to sort 10,000 channels at peak activity using 79 milliwatts.

The argument in one glance

Problem

Thousands of electrodes, and a person who wants to carry the device

A brain-machine interface (BMI) reads the electrical activity of neurons through a probe with many electrodes, and a computer turns that activity into a command, for example moving a robotic arm. The first step is spike sorting, deciding for each brief voltage pulse (a spike) which neuron produced it. Probe technology now offers thousands of channels, and an untethered device must sort them in real time on a battery.
What people did

Software sorters on GPUs, or small fixed hardware sorters

Software sorters such as the template-matching family are highly accurate. They run on a workstation with a graphics processing unit (GPU) after the recording is complete. Hardware sorters are built as fixed circuits so they can sit next to the probe and use little power.
Why it fell short

The accurate ones cannot be carried; the portable ones are inaccurate and small

A GPU draws tens to hundreds of watts and processes recordings after the fact, so it cannot be part of a wearable or implanted device. Hardware sorters simplify the algorithm to fit in silicon, lose accuracy as a result, and handle at most 128 input channels, far below what modern probes deliver.
This paper's idea

Measure what a faithful sorter needs, find the memory bottleneck, and design around it

Marple starts by analyzing the compute and memory that modern software sorters actually require. The analysis shows that the bottleneck is storing the neuron templates, not the arithmetic. Marple is a hardware pipeline with a fixed-function front end that filters the incoming channels down to regions of interest and a flexible vector back end that identifies neurons, plus a new mechanism that cuts template memory by 8 to 11 times. The design is projected to sort 10,000 channels at peak activity using 79 milliwatts in a 7-nanometre process. The paper also shows, for the first time, a machine-learning model that can replace the template-matching stage.

Why this problem is worth solving

A person who has lost the use of their arms can already control a cursor or a robotic hand through a

brain-machine interface

A system that records signals from the brain and translates them into commands for a computer or a device.

. Today that usually means a cable from the head to a rack of computers. The implant records; the computers decode. To make the device something a person can live with, the decoding has to move onto the device itself, and the device has to run on a small battery and stay cool enough to sit against tissue.

The signal that arrives from the probe is not a list of neurons firing. It is a voltage trace per electrode, sampled about 30,000 times per second. When a nearby neuron fires, it produces a brief pulse, a

spike

A short voltage pulse of about one millisecond that a neuron produces when it fires.

, that several electrodes see at once with different shapes and strengths. Several neurons near the same electrodes produce overlapping pulses.

Spike sorting

The process of detecting spikes in the recorded voltages and assigning each spike to the neuron that produced it.

is the task of untangling this: detect each spike, then decide which neuron it belongs to.

The scale is the problem. Probes such as Neuropixels expose around a thousand recording sites on one shank, and researchers are moving toward tens of thousands. The abstract frames the paper around one question: how much computation and memory does it take to sort spikes from thousands of channels and keep up with the probe? Without an answer, a designer cannot know whether an implantable sorter is possible at all.

What people did before, and where it broke

Software spike sorters. Tools in the template-matching family, such as Kilosort, learn a characteristic waveform, a

template
The typical voltage shape a particular neuron produces across the electrodes near it, learned from earlier spikes.
, for each neuron, and then match every incoming spike against every template. Where it broke. The matching is a large amount of arithmetic, so a GPU is needed to finish in reasonable time, and the tools are designed to process a complete recording after the experiment. A GPU cannot go in a wearable device, and after-the-fact processing cannot drive a prosthetic arm.
Hardware spike sorters. Fixed circuits next to the probe, designed for microwatts to milliwatts. Where it broke. To fit in silicon, they replace the full algorithm with simpler rules, such as comparing a few waveform features. The abstract reports that this costs accuracy, and that the existing designs handle only up to 128 channels.
The gap. No design combined the accuracy of the software algorithms with a power budget and channel count that fit an untethered device. The reason, according to the paper, is that nobody had characterized where the software algorithms spend their resources at thousands of channels.

Where Marple sits

From electrode voltages to identified neurons

Probe

Thousands of electrodes, each sampled about 30,000 times per second.
↓ →
Front end (fixed function) new

Filters the raw channels and picks out the regions of interest where a spike is happening.
↓ →
Template memory new

Holds one learned waveform per neuron. Marple compresses this store 8 to 11 times.
↓ →
Back end (vector unit) new

Matches each candidate spike against the templates and names the neuron.
↓ →
Decoder

Turns the spike train into a command for a cursor, an arm, or a stimulator.

Marple covers the three middle boxes. The decoder that acts on the sorted spikes is outside the paper.

The idea

This section describes what the abstract states, and explains the standard mechanism behind each statement. The exact circuits and the compression mechanism are in the full paper, which was not available; nothing below should be read as the paper’s specific design beyond what the abstract says.

Characterize first. The authors analyze the compute and memory requirements of modern software spike sorters as the channel count grows. The result named in the abstract is that the potential bottleneck is template memory storage. This makes sense from the shape of the algorithm: each neuron needs a template that spans the electrodes near it and the duration of a spike, so template storage grows with the number of neurons, which grows with the number of channels. Arithmetic can be shared over time; storage cannot.

Reduce template memory by 8 to 11 times. The abstract describes a novel mechanism for this reduction but does not describe how it works, and the full text was not available. Common approaches in the field include storing templates at lower precision, keeping only the channels where a template has meaningful amplitude, and sharing structure between similar templates. Which of these, if any, Marple uses is not stated in the abstract.

Split the work into a fixed front end and a flexible back end. The front end is fixed-function hardware, which is the cheapest way to run the same filtering on every channel at every sample. Its job is to reduce thousands of always-on streams to the few regions of interest where a spike is present. The back end is a vector unit, which is programmable, because the matching step must adapt to the number of neurons, the templates, and possibly a different algorithm later. The abstract calls this back end flexible for that reason.

A machine-learning replacement for template matching. The abstract says the paper demonstrates, for the first time, a machine-learning model that can replace the template-matching stage. A flexible vector back end is what makes such a swap possible without new hardware. Its accuracy and cost are in the paper and are not reproduced here.

Tracing one spike through the pipeline

One millisecond on a thousand-channel probe

This trace follows the standard detect-then-match structure that the abstract describes. Channel counts and numbers are illustrative; the paper's exact parameters were not available.

Step 1 of 5

Samples arrive

Every 33 microseconds, one new voltage sample arrives on each of 1,000 channels. Most channels show only background noise most of the time. At peak activity, many neurons fire close together in time.

per sample period: 1,000 values | typical: noise | occasionally: a spike spanning a few channels

Why it works

Most of the input is silence. Spikes are short and sparse, so a cheap always-on front end can discard almost all samples before any expensive matching, and the back end only works on regions of interest. Therefore the arithmetic cost scales with the number of spikes, not the number of channels.
Storage, not arithmetic, is what grows with the probe. Every neuron needs a stored template, and more channels means more neurons. Because Marple shrinks that store 8 to 11 times, the memory that would otherwise dominate area and power fits on a small chip.
Fixed function where the work is uniform, programmable where it is not. Filtering is identical for every channel, so a fixed circuit is the cheapest option. Matching depends on the neurons present and on the algorithm, so a vector unit keeps it adaptable, including to the machine-learning replacement the paper demonstrates.

What it costs

The power number is a projection. The abstract says the implementation is projected to use 79 milliwatts in a 7-nanometre process. This is an estimate from a design model, not a measurement of a fabricated chip.
Template compression is lossy in principle. Any method that reduces template storage by an order of magnitude discards some information. Whether and how much accuracy this costs is in the paper and not in the abstract.
Templates must come from somewhere. Template-matching sorters need an initial learning phase to discover the neurons and their waveforms, and templates drift as the probe moves relative to tissue. How Marple learns and updates templates was not available.
Comparison baselines are unstated in the abstract. The abstract gives the 128-channel limit of prior hardware and the GPU dependence of software, but not the accuracy of Marple against a named software sorter on a named dataset.

The evaluation

Three ways to sort spikes

Property	Software sorter on GPU	Prior hardware sorters	Marple
Accuracy	High
Channels	Thousands, offline
Power		Low
Runs on the device	No, after the fact	Yes	Yes, real time
Template memory	Unconstrained	—

Every Marple cell comes from the abstract. The full paper, with its methodology, datasets and accuracy results, was not available when this page was written.Underlined values explain themselves when clicked.

Where this stops working

Where this stops working, and what this page does not know

Marple is a projected design, not a fabricated chip, so the 79-milliwatt figure depends on the accuracy of the authors’ power model. Template matching itself has known limits: it needs an initial learning phase, it degrades when the probe drifts and the waveforms change, and overlapping spikes from two neurons are hard for any matcher. Whether Marple addresses drift or overlap is not stated in the abstract. This page was written from the abstract only. The full text is behind the ACM paywall, no preprint exists, and the author-hosted copy that search engines still list is no longer online. The 8-to-11-times memory reduction, the front-end and back-end split, the 10,000-channel and 79-milliwatt projections, and the machine-learning replacement are all stated in the abstract. The mechanism behind the reduction, the datasets, the accuracy numbers and the baselines are not, and nothing about them has been invented here.

If you remember only three things

1. Spike sorting turns thousands of raw electrode voltage streams into a list of which neuron fired and when. Accurate software sorters use template matching on a GPU after the recording is done, which cannot go in a wearable device. Existing hardware sorters fit the power budget but lose accuracy and stop at 128 channels.
2. Marple first characterizes what software sorters need at thousands of channels and finds that template memory, one stored waveform per neuron, is the bottleneck rather than arithmetic. It pairs a fixed-function front end that reduces the streams to regions of interest with a programmable vector back end that names the neuron, and a mechanism that shrinks template storage 8 to 11 times.
3. The design is projected to sort 10,000 channels at peak activity within 79 milliwatts in a 7-nanometre process, and the paper demonstrates a machine-learning replacement for template matching. This page is a draft written from the abstract: the compression mechanism, accuracy results and baselines are in the full paper and are not reproduced here.

Check yourself

Check your understanding

1. Why can an accurate software spike sorter not simply be placed inside a wearable brain-machine interface?
2. According to the paper, what resource becomes the bottleneck when a template-matching sorter scales to thousands of channels?
3. Predict what happens to the back end workload if the front end is removed and every channel is sent to the vector unit at every sample.
4. Why does Marple make the back end a programmable vector unit instead of a fixed circuit like the front end?

Sources

The paper is “Marple: Scalable Spike Sorting for Untethered Brain-Machine Interfacing” by Eugene Sha, Andy Wei Liu, Kareem Ibrahim, Mostafa Mahmoud, Christina Giannoula, Ameer Abdelhadi and Andreas Moshovos, University of Toronto, published at ASPLOS 2024, DOI 10.1145/3620665.3640357.

This explainer is marked as a draft because the full text was not accessible. The ACM Digital Library copy is behind a paywall and an anti-bot challenge, no arXiv preprint exists, Semantic Scholar lists the paper as closed access, and the author-hosted PDF that search engines still index returned an error page, including from the Internet Archive. Every claim attributed to the paper comes from its abstract. The background on spike sorting, template matching, neural probes and the fixed-versus-programmable hardware trade-off is standard material and is presented as such.