Your phone can perform billions of calculations in a second.

Your laptop can store thousands of movies.

Modern AI models can recognize faces, generate images, translate languages, and write code.

And yet, there is something strangely humbling about the human brain.

You can walk into a room you've never seen before, recognize the people in it, understand what they're saying, notice that someone is holding a red cup, and decide to pick it up—all without consciously performing a single calculation.

And the machine doing all of this biological “computation” is sitting inside your skull, consuming roughly as much power as a small light bulb.

So, are human brains actually more efficient than computers?

The answer isn't as simple as comparing the number of calculations per second or the amount of electricity consumed. A brain and a computer are built on fundamentally different ideas about how information should be represented and processed.

And this difference leads to a fascinating question:

What if computers didn't have to work like computers?

What if we could build machines that processed information more like biological brains?

This is the idea behind Neuromorphic Computing.

A Brief History of Computer Architecture

Since the mid-1900s, computing has been carried out primarily on machines following the so-called “von-Neumann” architecture, named after John Von Neumann. Based on his work on the project ENIAC during the Second World War. The fundamental architecture of all the computers since then, consists of a Memory and a central processing unit (CPU). CPU is connected to the memory via a digital bus which is responsible for transfer of data between them.

Now, this bus creates the real bottleneck in this architecture, because the amount of data the bus can transfer in a time-frame is limited. Modern CPUs on modern tasks require large amount of data be made available at rapid speeds, placing an increasing demand on the bottlenecking digital bus separating that data from the processor that needs it. This problem in itself will only continue to grow worse, and it is not the only problem being faced.

Neuromorphic Computing

Don’t let this name scare you, the idea behind neuromorphic computing is that instead of making computers process information in the same way they traditionally do, we can take inspiration from the way the human brain does it.

A conventional computer processes information through calculations on numbers. The brain works differently. Billions of neurons communicate with each other through short electrical signals called spikes, while their connection called synapses determine how strongly one neuron can influence another.

Neuromorphic computing tries to bring some of these ideas into computing systems. The goal is not to build an artificial human brain, but to create machines that can process information using principles similar to biological neural systems—such as spikes, interconnected neurons, and event-driven communication.

One of the main ways we can model this kind of computation is through Spiking Neural Networks (SNNs).

But what are Spiking Neural Nets?

Let’s first look at the most basic building block of the SNNs - Neuron

The Neuron

A neuron is a tiny cutie-patootie component of the network that can receive a signal from other neurons through synapses (analogous to edges in graph theory). These synapses have a weight assigned to each one of them, which affects how much impact the connected neuron would have on each other. These signals affect the neuron’s electrical state called membrane potential (nothing to be scared of, it’s just a value stored in a variable).

When this membrane potential crosses a threshold value, the neuron produces a short electrical signal called SPIKE, which travels to the neurons it follow. Followed by a complete reset of it’s membrane potential (i.e potential becomes zero and restores back when signals come).

If you notice, the key idea behind Spiking Neural Networks is this discreteness that spiking produces and more importantly, the timing of the spikes. Instead of continuous signals produced by traditional perceptrons.

Building the Complete Network

At first glance, an SNN might look very similar to the artificial neural networks we already know. It has neurons, connections between neurons, and weights that determine how strongly one neuron influences another. But there is one important difference: Neurons communicate using spikes.

Imagine three neurons connected together:

Neuron A → Neuron B → Neuron C

When neuron A fires, it sends a spike through its connection to neuron B. This spike contributes to neuron B's membrane potential. If enough spikes arrive and the potential crosses a certain threshold, neuron B fires its own spike, which can then be passed on to neuron C.

So the information flows through the network as a chain of events:

spike → voltage accumulation → threshold → spike → voltage accumulation → threshold → spike

And unlike a traditional neural network, where we might simply pass a number such as 0.73 from one layer to another, an SNN also cares about when something happens.

A neuron firing at one moment and the same neuron firing a few milliseconds later are not necessarily equivalent events. This introduces something that conventional neural networks don't naturally emphasize: time.

But there’s a problem, Image is made up of pixels, a microphone produces a continuous audio signals. None of these are discrete spikes that we are talking about. This brings us to first part of our complete SNN pipeline - The Encoder

The Encoder

The SNN needs the input to be in the form of “spikes occurring over time”. This is just an array of 0s and 1s where indices basically represent different time-steps.

Let’s take an example of an image. An image is a grid of pixels, and each pixel has value between 0 and 255. Let’s say we have a pixel A of value 200 and a pixel B of value 30. While a standard ANN would just expect us to normalize this number and feed it. For SNN, it’s a different case.

Let’s say we are using a type of encoder called rate-encoder — based on the idea that the higher value will have more frequent spikes.

hence the array of spikes for A and B will look like -

A = [0,1,0,1,0,0,1,1,1,0…]

B = [0,0,0,0,1,0,0,0…]

One can easily notice the difference in the number of spikes.

The important thing to understand is that encoding is not changing the information into something completely different. It is choosing a way to represent the same information using spikes. And rate coding is only one possibility. We could also encode information based on when a spike occurs, rather than simply how many spikes occur. Similarly, there are many encoding techniques depending on the given problem statement.

The Network

This is where the artificial neurons inside the SNN come into play. Imagine two neurons connected by a synapse:

Neuron A → Neuron B

When neuron A produces a spike, that spike travels across the connection to neuron B. The connection has a weight, which determines how strongly that spike affects neuron B. For example, suppose the connection has a weight of 0.4.

When A fires:

spike × weight = 1 × 0.4 = 0.4

Neuron B therefore receives an input of 0.4, which changes its membrane potential.

But one spike may not be enough to make B fire.

Suppose B has a threshold of 1.0.

After receiving the first spike:

membrane potential = 0.4

Since 0.4 < 1.0, B remains silent.

Later, another spike arrives from A:

membrane potential = 0.4 + 0.4 = 0.8

Still no spike.

A third spike arrives:

membrane potential = 0.8 + 0.4 = 1.2

Now the membrane potential has crossed the threshold.

Neuron B fires.

After firing, the neuron can reset its membrane potential and begin accumulating input again. Realistic neuron models can also include leakage, meaning that the membrane potential gradually decreases if new input does not arrive. This makes the timing of spikes important: two spikes arriving close together can have a much larger effect than the same two spikes arriving far apart.

Now imagine replacing our two-neuron example with thousands of interconnected neurons.

A spike from one neuron can cause another neuron to fire, which can cause another neuron to fire, creating a chain of activity throughout the network. Instead of simply passing numbers from one layer to another, the network continuously updates the neurons' internal states as spikes arrive. The weights, membrane potentials, thresholds, and timing of spikes together determine how activity flows through the network. Eventually, this activity reaches the output neurons.

But now we have another problem — the output is in the form of spikes, but we don’t want that, do we? Hence, we have the last component of our network — The Decoder

The Decoder

Similar to the approaches we have for encoding, there are different approaches for the decoding. For example - while predicting the digits from 0-9, let’s say we have 10 neurons in the output. We take the answer as which neuron receives the largest amount of spikes.

But wait a second, what about the weights? How do they get adjusted?

The Learning

This is essentially the analogue of the “backpropagation” in Artificial Neural Nets. The sudden jump nature of SNN makes training them more complicated. There are several approaches to deal with this.

One approach is inspired by biology and changes synapses according to the timing of spikes. This is known as Spike-Timing-Dependent Plasticity (STDP).

Another approach adapts the techniques used to train conventional neural networks, using methods such as surrogate gradients to make the spike-generation process trainable.

Completing what we started

So, coming back to the question we started with: is the human brain more efficient than a computer?

The honest answer is: it’s not really a yes-or-no question. The brain and a computer are built very differently, process information differently, and are efficient at very different things.

But that was never really the point of this blog.

What I wanted to highlight is something more interesting: when we try to push computing forward, we find ourselves looking back at nature for ideas.

After decades of building faster processors, larger memory, and more powerful AI systems, we are now studying something that nature has been doing for millions of years—the brain. We are taking inspiration from its neurons, spikes, connections, and event-driven way of processing information, and using those ideas to imagine a different kind of computer.

Maybe the future of computing isn't always about moving further away from biology.

Maybe, sometimes, moving forward means looking back.