The Vision

The Processor Dies. Memory Lives.

96.4% MNIST with Pure &|~ — No Float, No Gradient, No Backprop

Evolution never needed a floating-point unit. Neither do we.

Vision by Andreas Otto  |  18 June 2026
The computer of the future is not a processor with memory attached. It is memory that can compute.

​ The Evolution of Life and Perfect Randomness

We already have an artificial intelligence. Its name is Life.

Every brain on this planet — from the insect brain with 10,000 neurons to the human cortex — shares one thing: Not a single one uses a floating-point unit. No brain multiplies 32-bit floating-point numbers. No brain has ever computed a gradient. And yet: it can fly, hunt, love, write poetry.

Nature has no AdamW. Nature has no backpropagation. Nature has mutation + selection.

And that is exactly what we replicated.

​ Randomness as the Architect

We start with perfect randomness: W0 = random(). Thousands of random projections, all different, none trainable. This is our mutation — a vast field of meaningless, random perspectives on the world.

What does nature do with mutation? It tests, discards, retains. Millions of attempts, most meaningless, a few useful.

Our MAJ3 tree does the same. Each random projection is compressed into a 32-bit pattern — 32 yes/no decisions about whether a pixel pattern matches a neuron. Most patterns are noise. But a few carry information.

The key insight: We never train W0. It stays frozen — permanently random. The randomness itself is the feature space. The more random projections we have, the more likely we are to capture a useful perspective.

This mirrors evolution perfectly: random variation at massive scale, followed by selective retention of what works. No intelligent design, no gradient, no convergence — just enough randomness to cover the possibility space.

​ The Counter as Selection

Then comes the crucial step: we count. Not learn, not optimize, not backpropagate — just count.

"How often is this bit = 1 when the sample belongs to class 5?"

This is nothing but natural selection at a microscopic scale. A feature that frequently appears with a class becomes enriched. A feature that rarely appears becomes diluted (through the offset's negative evidence).

No gradient. No derivative. No chain. Only: count what works.

The Bayes Log-Score as Decision Organ

The brain has no argmax. But it has something mathematically equivalent: evidence accumulation. Each neuron fires or does not fire. Each bit in the MAJ3 output fires or does not fire. Each firing is a vote.

The Bayes log-score is the mathematically optimal way to weight these votes. A bit that often fires for class 3 receives high log-odds for class 3. A bit that never fires receives a high offset (negative evidence for all classes).

Nature does not do this consciously — but evolution has programmed exactly this logic into every brain over billions of years.

​ And Suddenly: 96%

What We Achieved

  • 96.4% on MNIST — with nothing but random W0, an MAJ3 tree of &|~ gates, a counter, and a Bayes log-score
  • No float. No AdamW. No gradient. No backprop.
  • Only mutation (random W0) and selection (counting + log-odds)

What It Means

  • Evolution took 3.5 billion years to build a brain that achieves 96% on MNIST
  • It did so with the same tools: randomness, majority vote, and evidence accumulation
  • We have now translated this proof into silicon

​ The Wrong Path

The Industry — Scales DOWN

FP32 → FP16 → FP8 → FP4 → ?
Every step downward hurts.
More precision? Build a smaller fab.
More speed? Build wider buses.
More efficiency? Move less data.
Scaling down hits zero.

Nature — Scales UP

32 bit → 64 bit → 256 bit → more!
Every step upward gives more information.
The container grows, the principle stays.
&|~. Same gates. Wider registers.
No end in sight.

​ The Promise

A DRAM chip that can only do &|~ — no FPU, no matmul, no ALU — will run a classifier achieving 96%. Memory is the processor. Randomness is the training. Time is the counter.

Evolution has shown: Intelligence does not need multiplication. It only needs: many random perspectives, a majority mechanism, and a counter that retains what works.

We have now translated this proof into silicon.

​ The Computer of the Future is Memory

The IT industry has maneuvered itself into a dead end. Two fundamental problems, one solution.

Problem #1

Massive Parallelism

The limit of parallelism is not the number of transistors, but the width of the DRAM row. A single row of a modern DRAM chip contains ~16,000 cells. Each cell can simultaneously perform an XNOR operation. 16,000 parallel bit operations in one cycle.

No SIMD, no VLIW, no SMT. Just one row using its full width. And there are millions of rows.

Problem #2

Local Energy

The electron no longer moves through the computer. It stays local. The XNOR operation happens at the memory cell. The analog summer uses the natural current flow of the row (Kirchhoff's law). The comparator sits at the end of the row. The data never leaves the row.

Energy drops from ~500 pJ (conventional) to ~1 pJ (DRAM-native). A factor of 500.

Memory Becomes the Computer

The DRAM-native AI in its final form is no longer a processor with attached memory. It is memory that can compute. Each row is a rudimentary processor. Millions of rows work in parallel. The only thing that leaves the DRAM is the part of the information destined for the outside world — the classification, the decision, the command.

And with this command, memory can simulate a classical processor that executes algorithmic software. The virtual processor runs on DRAM, not on silicon. The real "processor" is the DRAM row itself, computing with &|~.

The computer of the future has no von Neumann bottleneck — because there is no separation between processor and memory. There is only memory. Memory is the processor. Software is the wiring. Efficiency is the locality of the electron.

The processor dies. Memory lives.

← Research Results