I've just finished reading Charles Petzold's book, Code: The Hidden Language of Computer Hardware and Software. In it Charles explains building relays into gates, gates into logic components, and logic components into computing machines.

He talks about the book TTL Data Book for Design Engineers which first came out in 1973. (I'm assuming people had lists of TTL gate chips prior to this). This talks a lot about the Texas Instruments 7400 series of logic gate chips.

Now to me it seems you could combine TTL chips (or relays or transistors) into a CPU using the instructions in this book. But everything online says "use FPGAs instead! It's easier for that scale! [Unless you're getting the concepts and want to see the end to end view]". Fair enough - some pragmatism is good - it depends on what the outcome is.

When you look at the structure of an FGPA - it appears to only have slightly more complexity than a 4-bit adder.

enter image description here

Now I don't know when the first four-bit adder was invented. (My guess is it came out of Claude Shannon's work on boolean logic in 1948).

Now we know that the first FPGAs in chips went on sale in 1984. But people but have been building them out of TTL, transistors and vacuum tubes before that.

So somewhere between 1948 and 1984 someone must have thought of the idea of FPGAs.

My question is: When was the concept of the FPGA invented?

  • \$\begingroup\$ This link has some facts about the history of fpga's: en.wikipedia.org/wiki/Field-programmable_gate_array#History \$\endgroup\$
    – zack1544
    Commented Jan 6, 2017 at 1:43
  • \$\begingroup\$ In the wikipedia link: "Xilinx co-founders Ross Freeman and Bernard Vonderschmitt invented the first commercially viable field-programmable gate array in 1985 – the XC2064." \$\endgroup\$
    – zack1544
    Commented Jan 6, 2017 at 1:45
  • 8
    \$\begingroup\$ You need to research PAL (and later GAL etc) as bridge technologies - the modern FPGA did not appear overnight! \$\endgroup\$ Commented Jan 6, 2017 at 1:46
  • 4
    \$\begingroup\$ You are wrong @hawkeye. The basic cell of an FPGA usually has one or two flip-flops and that marks a huge difference against a "simple four bit adder" which is a purely combinational circuit. Then you have the routing, which gives you the possibility of making complex logic. A brain is not only the neurons, it is also the interconnections. An FPGA is formed of LUTs, FFs, and routing (and nowadays huge complex hard IPs, like complex processors, transceivers, and Mbits of RAM). \$\endgroup\$ Commented Jan 6, 2017 at 5:29
  • 2
    \$\begingroup\$ To expand on what @Claudio says, the thing about FPGA is that it is configurable. There is no reason to make a FPGA out of discrete TTL logic chips, since you can just arrange the basic chips differently to obtain the same possibilities of reconfiguration. Basically, yes, you can make a CPU out of logic chips, but it doesn't make sense to make a FPGA out of logic chips. So the statement "But people but have been building them out of TTL, transistors and vacuum tubes before that" is most probably wrong. Before FPGAs, there were PAL and GALs, but all those were single chips. \$\endgroup\$
    – dim
    Commented Jan 6, 2017 at 8:55

2 Answers 2


Before the "FPGA" with either EPROM (Altera, 1984) or SRAM (Xilinx,1985) there were families of programmable logic, where the programming was done by blowing fuses on-chip to break unwanted connections.

This was a one-way process; you can't un-blow a fuse, so these were generally "use once" devices, though sometimes you could ensure that any design changes you made were blowing additional fuses.

These were generically called PLDs - Programmable Logic Devices - though the first specific brand were known as PALs - Programmable Array Logic. I've seen claims from AMD marketing that they invented these - not technically correct, though they bought MMI (Monolithic Memories Inc) the company that did.

PALs were usually a much simpler structure than FPGAs, generally a comprehensively interconnected network of AND-OR gates, with or without registers on the outputs - you broke the connections you didn't need. Each could typically replace 4-8 TTL SSI or MSI packages, a useful saving in board space, and reduced the number of board design changes required.

AMD came along with the more complex but more flexible PAL22V10 a little later, then after a few years, went on to buy MMI.

Programming was usually with a low level HDL - usually PALASM or CUPL - to generate a programming file listing the fuses to be blown. Then insert the chip into a programmer and load the file...

I think the first PALs were available from MMI around the mid 70s, and popular by about 1980. In addition to the MMI databook (1978 onwards) there was a Systems Design Handbook (my 2nd ed was from 1984, can't find online) was a collection of application notes covering basics all the way up to audio spectrum analysers, and, like the handbook, mainly notable for a series of cheesy cartoons...

enter image description here

The schematic for an entire chip, unprogrammed, looked like this:
enter image description here

And a program (in this case, one of MMI's own examples, for a 4-bit counter), in PALASM looked like this...
enter image description here

Pretty basic, but easier than marking the fuses you wanted to destroy on the schematic above...

Note the two lines starting "CLK" ... they are names for the pins in order, numbered from 1 to 20. These correspond to the schematic above (which doesn't show pins 10 = GND or 20 = VCC, which are predetermined). Comparing this with the schematic you'll see that CLK and /OC are also predetermined, and all the other input pins are on the left, outputs (registered) on the right.

Also note that this design is for a 16R6 but it'll fit a 16R8 because pins 12 and 19 (which are unregistered in the 16R6) are unused - i.e. NC - in this design.

In practice you'd probably use an off-the-shelf counter like the 74163 instead, unless it was Saturday and Stores was closed, or someone else had goofed the polarity of the Load input.

Some more info here...

And for some perspective on work in that era, see "The Soul of a New Machine" by Tracy Kidder - the book mentions the advantages of a newly available form of programmable logic, and the timeframe pretty much means it has to be PALs.

Following on from these were mask programmable devices, much larger, but much less amenable to small scale development - notably the Ferranti ULA, which made the BBC Micro and Sinclair ZX81 possible around 1982. These offered a few hundred or a few thousand gates. Like mask programmable MCUs, you sent off your paper tape, got a thousand parts back aftel 6 weeks, and prayed that your design and testing had been thorough enough...

  • 2
    \$\begingroup\$ I always felt guilty when, at $5 a pop, I'd throw away a PAL due to an error I made using PALASM. "Soul" is a great book and described the work I did perfectly. \$\endgroup\$
    – Rob
    Commented Jan 12, 2017 at 12:21

But people [must] have been building them out of TTL, transistors and vacuum tubes before that.

In that era, nobody would have gone to the trouble and expense of building electronically field re-configurable logic systems. What they built instead were mechanically reconfigurable systems using wire-wrap. It looks like this (from this page):

Mac wirewrap

Obviously that's a bit slower to work with than a modern FPGA system, but given the tooling of the time and lack of existing electronics design software, it was normal for people to design on paper and transfer directly to a physical prototype.

It wasn't just for prototyping, small to medium volume manufacturing was done this way. See MIT Lisp Machine:

enter image description here

It was possible to field-modify these by cutting or unwrapping wires then adding new ones. This was routinely done for bugfixes or customer service "patches".

  • \$\begingroup\$ The Cray machines were built in a similar fashion, too, but hardwired in a different way between individual, interconnected boards. \$\endgroup\$
    – Rob
    Commented Jan 12, 2017 at 12:22
  • \$\begingroup\$ National Semi introduced the UltraViolet Erasable ROM/UVPROM about 1970. Life was good. With an external ProgramCounter and an ALU, you had a computer. \$\endgroup\$ Commented Feb 4, 2017 at 7:46
  • \$\begingroup\$ Also, there was an easy way to deal with bunches of complex but stateless logic - just shove it into some kind of PROM. \$\endgroup\$ Commented Aug 13, 2019 at 2:24

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.