The first FPGA: how a 1985 chip learned to be any circuit

Picture a single chip that can become almost any digital circuit you ask for. This morning it is a traffic-light controller. This afternoon, with no soldering and no trip back to the chip factory, it is a music synthesizer, then the flight logic for a small satellite, then a tiny computer running its own programs. You never rewire it. You reload it, the way you reload a document on a laptop, except what you are loading is not software. It is the wiring diagram of hardware itself.

That sounds like a very modern trick. The first chip to pull it off shipped in 1985: the Xilinx XC2064, the original FPGA (field-programmable gate array). It kicked off a multi-billion-dollar industry from a grid of just 64 little blocks, and the best part is that you can still see exactly how the magic works, right down to the individual transistors.

Silicon used to be set in stone

Before this, building a custom chip meant committing every wire in advance. You sent your design to a fabrication plant, waited months, spent a fortune, and got back silicon that did exactly one thing forever. Make a mistake, or change your mind, and you started over. There were softer options (a small programmable-logic PAL here, a memory chip there), but nothing let you lay out a whole circuit of your own and then change it at will.

The XC2064 asked a cheeky question: what if the chip arrived as a blank grid, and you decided, after it was made, what each part did and how the parts connected?

A bet on cheap transistors

The idea came from Ross Freeman, who co-founded Xilinx in 1984 to build it. His bet was counterintuitive. To make a chip reprogrammable you have to spend a lot of extra transistors on the machinery of flexibility (little memory cells everywhere, a switch on every wire) that a fixed chip would never waste. Freeman wagered that transistors would keep getting cheaper and more plentiful, year after year, until "wasting" them on configurability became the obvious trade. History proved him right so thoroughly that he was later inducted into the National Inventors Hall of Fame for it.

Here is the whole chip, conceptually: a grid.

Sixty-four configurable logic blocks in an eight-by-eight array, ringed by input and output pins, laced together by wiring you get to program. That is essentially the entire invention. Everything modern FPGAs have added since is more of the same, just a great deal more of it. To see why a grid of blank blocks can become anything, you only need three ideas.

Idea one: a truth table you can rewrite

Ask a beginner "how do you build a logic gate?" and they will reach for transistors wired into an AND or an OR. The FPGA does something sneakier and far more flexible: it uses a tiny memory.

A look-up table (LUT) is just a handful of stored bits with a selector on the front. Give the XC2064's function generator up to four inputs, and those four inputs form a 4-bit address that picks one of 16 stored bits as the answer. Those 16 bits are the truth table of whatever function you want, written straight into hardware.

Want a 4-input AND? Store a 1 in the single slot that means "all inputs high," and zeros everywhere else. Want OR, XOR, a majority vote, or some nameless one-off function? Just store a different 16 bits. One physical circuit, every possible gate, chosen after the chip was built. That is the "aha" at the heart of every FPGA, and you can feel it in about ten seconds. Edit the INIT bits below and press Run:

Idea two: bolt on a memory bit

Logic that only reacts to its inputs (combinational logic) can compute, but it cannot remember. So each block pairs its look-up table with a single flip-flop, a one-bit memory that updates on the clock. A small configuration switch decides whether the block hands out its raw computed value or the clocked, remembered one.

A LUT to compute anything, plus a flip-flop to remember it: that pairing is enough to build counters, state machines, and eventually whole processors, sixty-four little pieces at a time.

Idea three: wires you can reroute

Blocks are only useful if they can reach each other, and this is the part that feels most like sorcery. Running between and around the blocks is a mesh of wires, and at the crossings sit programmable switches. Turn a switch on and two wires connect; leave it off and they pass by untouched. Setting thousands of these switches is how you draw your particular circuit's connections onto the blank grid.

So where does the chip keep all these choices, the 16 bits in every look-up table and the state of every routing switch? In ordinary static memory cells (SRAM) sprinkled across the die. The XC2064's full configuration is only about 12,000 bits, a "bitstream" you load into the chip at power-up. Change the bitstream, change the chip. One quirk of using SRAM is that the configuration is volatile, so the FPGA forgets everything when the power drops and reloads its personality from an external memory each time it wakes.

Peeling back the silicon

The wonderful thing about a chip this early and this simple is that it is small enough to fully reverse-engineer. The engineer Ken Shirriff did exactly that: he dissolved the packaging, photographed the bare die under a microscope, and traced the actual layout. In his write-up you can pick out the grid of logic blocks, the little SRAM cells holding the configuration, and the routing switches, all real, physical structures that match the three ideas above. It is one thing to read that a LUT is "16 bits of memory," and quite another to look at the photograph and see those memory cells sitting on the silicon.

By the numbers

The first FPGA was, by today's standards, adorable:

• 64 logic blocks, about 1,000 logic gates' worth of circuitry.
• Roughly 85,000 transistors on a 2-micron process (features hundreds of times larger than those on a modern phone chip).
• Around 58 user pins and about 12,000 configuration bits.
• Xilinx did not even call it an "FPGA" at first. The marketing name was a Logic Cell Array; the term we use now came a little later.

It was not cheap to design for, either. The chips were priced for industry, and the software to lay out a design ran on expensive workstations and cost thousands of dollars, a nice reminder of how far the free, in-browser tooling of today has come.

From 64 blocks to ten million

Freeman's bet on cheap transistors did not just pay off, it compounded for four decades.

The grid never stopped growing. Sixty-four blocks became hundreds, then thousands, then millions of logic cells, now joined by dedicated multipliers, megabytes of on-chip memory, and fast transceivers. The same reprogrammable-grid idea from 1985 now accelerates AI models in data centers, filters signals on spacecraft, runs the split-second logic behind high-frequency trading, and prototypes the very chips that will one day replace it. All of it traces back to that eight-by-eight square.

The wonder of it

Strip away forty years of scaling and the core idea is still startling: hardware you can program like software. A blank grid of tiny truth tables and switchable wires, waiting for you to tell it what to be. The first one held 64 blocks and a simple bet that the future would have transistors to spare. It did, and here we are.

Curious to hold the atom of that idea in your hands? The four-input LUT above is the real thing: change its 16 bits and watch a different gate fall out. From there, the RTL recipes build these blocks up into synchronizers, counters and FIFOs, and the playground lets you wire your own little grid, no 1985 workstation required.

Further reading: Ken Shirriff's die-level teardown, "Reverse-engineering the first FPGA chip," on righto.com, and the history of the FPGA on Wikipedia.