A field-programmable gate array, or FPGA, is an integrated circuit that the user can configure after it leaves the factory. Where a conventional processor runs a fixed instruction set and an application-specific chip is etched once for a single function, an FPGA ships as a blank fabric of logic that the designer wires into whatever digital circuit is needed. The “field-programmable” in the name is literal: the device is programmed in the field, by the customer, rather than fixed at the foundry.
The vendor’s own documentation describes the building blocks plainly. An FPGA is made of an array of configurable logic blocks connected through a programmable interconnect, and as AMD (which acquired Xilinx) puts it, the device “can be reprogrammed to desired application or functionality requirements after manufacturing.” The configurable logic blocks are built around look-up tables and flip-flops; the look-up tables store a truth table that implements any small Boolean function, and the programmable routing stitches those blocks together into larger circuits. Loading a new configuration bitstream turns the same silicon into a different machine.
Xilinx shipped the first commercially viable FPGA, the XC2064, in 1985, founding an industry that gave hardware engineers a way to build custom digital logic without committing to the cost and lead time of a custom chip. A design is captured in a hardware description language such as VHDL or Verilog, synthesized into a configuration, and loaded onto the device. If the design is wrong, the engineer fixes the source and reloads, in minutes rather than the months a silicon respin would take.
That combination of custom-hardware performance with software-like iteration is why FPGAs occupy a distinctive niche. They are used to prototype chips before committing to an ASIC, to accelerate workloads such as networking, signal processing, and increasingly machine-learning inference, and to fill applications whose volumes never justify a dedicated chip. The trade-off is that an FPGA is slower and less power-efficient than a fixed ASIC implementing the same function, because the programmability itself costs area and delay.
The FPGA sits at a particular point on the spectrum of how computation gets done. A general-purpose CPU executes whatever software you hand it but spends energy decoding instructions; an ASIC does one thing at maximum efficiency but can never change; the FPGA splits the difference, offering hardware that behaves like one fixed circuit today and a completely different one tomorrow. It is, in effect, the gate between software and silicon.
Reconfigurable logic remains a working part of modern systems rather than a historical curiosity. Data centers deploy FPGAs as accelerators, test labs use them to emulate not-yet-fabricated chips, and embedded designs lean on them where a fixed processor would be too rigid and a custom chip too expensive. The same idea that began with a small 1985 array of logic blocks now scales to devices with millions of them.