Tarski neuromorphic chip render
neuromorphic Computing

AI that thinks in charge,
not clock cycles

A programmable analogue spiking neural network chip, built from discrete off-the-shelf components. Its analogue core classifies digits at microjoules per inference: three orders of magnitude below the digital overhead on the same task.

7.4µJ
Analogue compute per inference
85.1%
MNIST, emulated board round-trip
6,000,000×
Faster simulation than SPICE
The Problem

AI is devouring the grid

Data centres in Ireland already consume over 20% of the country's electricity. Frontier AI labs are building gigawatt-scale facilities that rival entire cities. And leaders in the space are clear: this is accelerating, not slowing down.

269 kWh
Energy for a single frontier model run on 16× H200 GPUs. No battery can hold that.
10 GW
OpenAI's Stargate capacity commitment. Roughly Ireland's entire peak demand, just for AI.
Water consumption
19 million litres/day
A single large data centre consumes as much water as a town of 50,000 people. This water evaporates during cooling and cannot be recovered.
Why this matters for Tarski
0 water
Tarski's analogue core uses 7.4 microjoules per inference — three orders of magnitude below the digital overhead on the same task. No heat. No cooling. No water. neuromorphic inference at the edge eliminates the data centre from the equation entirely.
Energy per device
Battery capacity (solid) vs. daily GPU inference energy (striped). Toggle to linear to see the real punchline.
Battery capacity
24h energy need
On a linear scale every other bar vanishes. Running Kimi K2 for one day consumes 269 kWh -- the stored energy of 117 Optimus robots, 19,300 iPhones, or 53,800 brain implants.
What is Tarski

A chip that computes
with physics, not code

Traditional AI
Simulating a rainstorm on a spreadsheet. Every number calculated, every cycle.
vs
Tarski
Actually making it rain. Electrons behaving like neuron. Physics doing the math.
Billions of multiply-accumulate operations per inference. Energy spent describing physics.
Capacitors charge. Resistors leak. Comparators fire. Zero multiply operations. Just physics.
How It Works

Two kinds of neural network

Traditional AI

Network Behaviour

Every neuron fires, every connection computes. All at once, every cycle.

Signal Type

A smooth, continuous stream of numbers, always flowing.

Timing

A rigid clock. Everything in lockstep.

Everything computes. All the time.

Like leaving every light in a building on to read one book.

Tarski (SNN)

Network Behaviour

Only active neurons fire. The rest stay silent.

Signal Type

Sharp spike, only when something happens. Silence is information.

Timing

No clock. neurons respond when events arrive.

Only what matters computes. Only when it matters.

Like the brain: billions of neuron, only a fraction active at any moment.

The neuron

Analogue LIF circuits

Each of the 19 neurons on the board is a real RC circuit implementing the leaky integrate-and-fire (LIF) model: charge up, leak away, fire at threshold, reset. The equation isn't numerically approximated — it's soldered.

Integrate

Weighted synaptic currents charge a 10 nF membrane capacitor. Multiple inputs sum for free via Kirchhoff's current law — no adder circuit exists.

Leak

A parallel 120 kΩ resistor drains the capacitor with τm = RC = 1.2 ms. Exponential decay makes the neuron forget old inputs — timing becomes information.

Fire

When the membrane crosses threshold (0.60 V hidden, 1.15 V output), an LMV7219 comparator fires a spike, stretched by an RC pulse extender so it can drive the next layer.

Reset

An analog switch (SN74LVC1G66) pulls the membrane back to rest, with a hysteresis network adding breathing room against double-fires.

The synapse

A weight made of matched transistors

The project's novel contribution: a fully programmable analogue synapse with no variable-resistance element. As best as the team can tell, it is the first fully programmable analogue spiking synapse array demonstrated at this scale on a single discrete-component PCB.

Binary-weighted mirrors

A reference current (~0.435 µA) is copied by matched BJT current-mirror banks — ×1, ×2, ×4 — switched in and out by a shift register. Weight magnitude is which mirrors are enabled.

Signed by topology

A sign bit routes through either the PNP bank (excitatory, injects charge) or the NPN bank (inhibitory, drains it). Result: signed integer weights in {−7 … +7} — 1 sign bit, 3 magnitude bits.

Gated by spike

Current flows onto the downstream membrane only while an upstream spike is asserted. Multiply-accumulate collapses to a gated current — the multiply is just a switch.

Built to scale

~25 discrete parts per synapse on the demo board. In silicon, the identical function maps one-to-one onto a single floating-gate transistor — the discrete design is a deliberate proof of concept for that ASIC path.

Gilgamesh Simulator

6,000,000× faster than SPICE

Designing analogue hardware means simulating real physics. SPICE takes ~75 seconds per inference at default tolerances — half an hour at the full physics horizon. Training needs millions of forward passes. Gilgamesh makes that possible.

SPICE vs Gilgamesh

One MNIST inference through the 36-12-10 spiking neural network, on the same laptop.

Training requires millions of these forward passes. A single forward-only epoch in SPICE is ~52 days of wall clock, and SPICE cannot train at all. Gilgamesh does 15 full epochs in under six seconds.

SPICE
Industry Standard
MNIST neural Network // 36-12-10 spiking Architecture
1xreal-time
Simulating...0%
00:00
elapsed time
Gilgamesh
Custom Engine
Same network. Same physics. Written in Rust.
Simulating...0%
0.000s
elapsed time
6,000,000× faster
Same physics, validated against SPICE spike-for-spike in 10 of 13 scenarios: ~12 µs per inference against SPICE's ~75 s.
That speed is what makes training possible. A run needs millions of forward passes, and the architecture search behind the final board needed every one of them; SPICE cannot train at all.
SPICE75.0s
Gilgamesh0.000012s
Accuracy (f32)91.38%
Arch36-12-10 SNN
Proven Results

Architecture validated. Hardware on the bench.

We validated the architecture in simulation, end to end. The 36-9-10 demo board is now populated and under test — physical spikes from physical neurons, coming back from the oscilloscope. End-to-end MNIST on the board at the predicted accuracy is the current bring-up goal.

MNIST Classification

Handwritten digits fed as rate-coded currents, classified by counting output spike. Through the full emulated board round-trip — real firmware, real schematic, real part tolerances — the pipeline holds 85.1%, settling at 83.4 ± 0.4% across ten virtual manufacturing draws.

85.1%
Emulated board round-trip accuracy

Minimal Architecture

The demo board implements a 36-9-10 network: 36 inputs (6×6 pixels), 9 hidden LIF neuron, 10 outputs. 414 logical synapses compress to 99 physical ones via DAC-driven input current sources; the 90 hidden-to-output synapses are fully independent current-mirror weights.

99
Physical synapses (414 logical)

Microjoule Inference

The analogue core uses ~7.4 microjoules per inference (emulator estimate), roughly three orders of magnitude below the digital overhead on the same 25 ms window. The board as built draws ~141 mW, at parity with the 140 mW Arduino baseline; one conservative comparator choice accounts for 74% of that, and a drop-in swap projects ≈37 mW.

7.4 µJ
Per inference. Zero idle.
Demo Board

See it classify digits

A 6×6 pixel image goes in as rate-coded current. spikes come out. The neuron that fires most wins. The analogue core runs on microjoules.

Input (6×6 pixels)
Tarski Chip
Tarski SNN chip
Classification
1
spike count: 19/25
highest spike count wins
36
Input channels (6×6)
9
Hidden LIF neuron
10
Output neuron (0-9)
Why It Matters

What milliwatt AI unlocks

Wearable ECG Monitoring

ECG traces are temporally rich, low-dimensional, and a natural fit for a rate-coded SNN. The training pipeline already supports time-varying streams — this is the named near-term application target.

First target
Once bench bring-up completes

Always-On Edge Monitoring

Anomaly detection that sips power. A nano-power comparator swap drops the board to ≈37 mW; the planned sub-1.2 V successor projects into single-digit milliwatts.

≈37 mW
Projected board power, one part swap

A Path to Silicon

Each ~25-part discrete synapse maps one-to-one onto a single floating-gate transistor. Trained weights transfer directly — the board is a working proof of concept for the ASIC.

1 transistor
Per synapse, in the silicon version
Benchmarks

Architecture performance on MNIST

MNIST handwritten digit classification is the standard benchmark for proving AI hardware feasibility. These results validate that Tarski's analogue circuits can learn and classify; they are not a production deployment target. All figures are simulation/emulator; board-measured accuracy is the current bring-up goal.

ArchitectureImagesynapseModeAccuracy
24-6-103×8204Full precision (f32)80.06%
36-9-106×6414Full precision (f32)89.34%
36-12-106×6552Full precision (f32)91.38%F32 BEST
36-9-106×64143-bit QAT + noise87.4%BOARD CONFIG
36-9-106×6414Emulated board round-trip85.1%
36-9-106×641410-board mismatch draws83.4 ± 0.4%
Software Stack

Gilgamesh: train, simulate, deploy

14,600 lines of Rust. Surrogate-gradient training fused into a single compiled kernel: 15 MNIST epochs in 4.87 seconds on a laptop CPU, 3-bit quantisation-aware, with noise injection matched to real component tolerances — and validated against SPICE spike-for-spike.

neuron/forward.rs
let decay = (-dt / tau_m).exp(); let steady = input * tau_m; mem = steady + (mem - steady) * decay; // RC membrane dynamics let fired = mem >= threshold; // Threshold crossing if fired { mem = 0.0; }
terminal
# Train a physics-mode SNN $ gilgamesh train --config physics.json # Evaluate on test set $ gilgamesh evaluate --model model.json Accuracy: 85.50% (8550/10000) # Generate SPICE netlist $ gilgamesh spice --model model.json Written: tarski_36_9_10.cir Components: 414 synapses, 19 neurons
The Board

Silicon. Solder. Signals.

The 350 × 350 mm four-layer PCB came back from JLCPCB pre-assembled: 3,442 components, every neuron, comparator and synapse mirror bank already mounted. Bring-up was a genuine resurrection — three stacked power faults peeled back one by one (90 hand-cut traces among them), a threshold rework across all 19 neurons, and the pulse-extender fix the emulator prescribed before the board ever reached the bench. It now powers cleanly: we're driving inputs, capturing spikes on the scope, and verifying the hardware behaves the way Gilgamesh said it would.

Currently under testSummer 2026
Team

Built by

Co-Designer

Third-year EEE student at University of Galway. Designed the neuron and synapse circuits, built the Gilgamesh simulator and the hardware-accurate board emulator, and wrote the training pipeline. Runs Eltrus Limited, a medical software company serving 400+ patients.

Co-Designer

Hardware co-designer on the 3,442-component PCB. Led the board layout and routing, built the small-scale prototypes and the Arduino digital baseline, and wrote the oscilloscope measurement suite.