What Is an FPGA? A Chip You Can Rewire After It's Made
An FPGA is a chip whose logic circuits can be rebuilt again and again after it leaves the factory. Inside are huge numbers of small answer tables (LUTs) and wires whose connections can be switched. Once you load a set of settings, they work together as the circuit you want. An FPGA is slower than a custom-made chip (ASIC) and uses more power. Its strength is that you skip the cost and time of making a new chip.
What you'll learn
- What "a circuit you can rewrite later" means, and how that differs from rewriting a CPU's program
- How the three parts inside an FPGA work (LUTs, flip-flops and wiring), using AND and XOR as examples
- How FPGA circuits are made, and when to pick an FPGA or a custom chip (ASIC)
- Where FPGAs are used, and a short history of the main makers
Prerequisites: it helps to know logic gates such as AND and XOR, and truth tables. "How Do Computers Use Binary?" explains them.
In everyday life
You rarely find an FPGA inside a phone or a home appliance. FPGAs are common in cell towers, test and measurement equipment, data center servers and satellites. These are machines made in small numbers, or machines whose job may need to change after they ship.
FPGAs are also a must for companies that develop new chips. Before a chip goes to the factory, the designed circuit is loaded into an FPGA. This checks that it really works.
What is an FPGA? A chip whose circuit is decided later
An ordinary chip has its designed circuit built in at the factory. How its transistors connect is fixed once it is made and cannot change ("What Is an Integrated Circuit?"). A CPU's circuit is fixed too. What you can change in a CPU is the list of instructions the circuit runs, that is, the program ("What Is a CPU?").
An FPGA is different. It is a chip whose circuit itself you decide after you buy it. Inside, small parts that can take on any job sit in a grid, linked by wires. You set what each part does and how they connect. Then the chip runs as that circuit.
FPGA stands for Field-Programmable Gate Array. It means "an array of gates that can be programmed in the field," that is, by the user rather than at the factory.
Part 1: The LUT, a small table of answers
What a logic circuit does can be written as a truth table. This table lists every combination of inputs and the output for each one. A 2-input AND, for example, has four input combinations, so its table has four rows.
Instead of building the circuit from gates, an FPGA writes this table straight into a tiny memory. The 0s and 1s on the inputs pick a row of the table. The chip then outputs the value stored in that row. Because it looks up the answer in a table, this part is called a lookup table (LUT).
A 2-input LUT is made of four storage boxes and a circuit that picks one box. To make an AND, you write 0, 0, 0, 1 into the four boxes from top to bottom. With inputs A = 1 and B = 1, the fourth box is picked, and out comes 1. Every other input gives 0, so it works just like an AND.
Now rewrite the same LUT's boxes as 0, 1, 1, 0 from top to bottom. It now outputs 1 only when the two inputs differ. That is what XOR does. You do not swap any gates. Just rewriting what is in the boxes turns it into a different circuit.
| A | B | Boxes for AND | Boxes for XOR |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 0 | 0 | 1 |
| 1 | 1 | 1 | 0 |
There are 16 ways to fill four boxes with 0s and 1s. There are also 16 possible 2-input logic functions in total. A 2-input LUT can become any one of them.
The LUTs in real FPGAs have more inputs. AMD's 7 Series FPGAs, for example, use 6-input LUTs. They have 64 boxes, which is 2 multiplied by itself six times. One such LUT can make any 6-input logic function.
Part 2: Flip-flops remember results
A LUT's output depends only on its inputs at that moment. On its own, it cannot remember "what the value was a moment ago." Some circuits need a part that holds a value. Examples are a counter, or a circuit that passes a calculation along in stages.
So an FPGA places a flip-flop right next to each LUT. A flip-flop is a part that remembers one bit, a 0 or a 1. It takes in its input only at the instant a set signal arrives. It then keeps outputting that value until the next signal.
This signal switches between 0 and 1 at a steady pace, and it is called the clock. It is the same kind of signal as the "3 GHz" of a CPU. In this article, a group of several LUTs and flip-flops is called a "logic block."
Circuits whose output depends only on their inputs differ from circuits that also use stored values. "Combinational vs Sequential Logic" sums up the difference in a table.
Part 3: Wiring whose connections can be switched
Many wires run up, down and across between the logic blocks. Where wires cross, there is a switch that can connect them or keep them apart. Each switch is really a transistor. Whether it is on or off is set by the 0 or 1 in a storage box beside it.
Say you want to send one logic block's output to another block. You turn on several switches along the way to make a path. Which switches are on decides how the circuit is wired.
The wires and switches must handle any circuit you might load. So the chip includes paths that may never be used. That takes extra transistors and extra area. This is one reason, as we will see, that an FPGA is slower and uses more power than a custom chip.
Built-in special blocks
A big calculation such as a multiply needs many LUTs and runs slowly. So today's FPGAs also come with circuits for fixed jobs, built in from the start. These are called hard blocks.
- DSP blocks: circuits that do a multiply and an add together, fast. DSP stands for "digital signal processing." They are used for sound and radio signals, and for AI math
- Block RAM: memory on the chip that holds larger amounts of data
- High-speed transceivers: circuits that send data to other chips fast, over only a few wires (SerDes)
- CPU cores: some products include Arm or other processors. One chip can then hold a part that runs programs and a part where you build circuits
The settings are loaded at every power-up
The contents of the LUT boxes and the on/off state of every wiring switch are all data made of 0s and 1s. Bundled into one file, this data is called a bitstream. "Writing a circuit" into an FPGA means loading this data into its storage boxes.
Most FPGAs use a kind of memory for these boxes that loses its contents when the power goes off (SRAM). So each time the power comes on, the FPGA reads the bitstream again. It reads it from flash memory or similar on the same circuit board. Until loading is done, the FPGA does not work as the intended circuit.
Some products keep their settings even when the power is off. Microchip's PolarFire series, for example, stores its settings in a type of flash memory. It needs no separate memory for the settings and can start working right after power-up.
How is an FPGA circuit made?
Making an FPGA circuit is much like designing a custom chip (ASIC). The big difference is the last step. Instead of sending the design to a factory, you create a bitstream and load it into the FPGA.
- Describe the behavior: you write how the circuit behaves in a hardware description language (HDL). The most common ones are Verilog and VHDL.
- Turn it into a circuit: software converts that behavior into a mix of LUTs, flip-flops and hard blocks. This step is called logic synthesis.
- Place and connect: software decides which logic blocks to use and which switches link them. This is called place and route.
- Load it: the result becomes a bitstream, which is loaded into the FPGA.
- Test it: you run it and check. If something needs fixing, you go back to step 1.
An HDL looks like a programming language, but what you write is the shape of a circuit, not an order of instructions. "Verilog vs VHDL" compares the two languages.
These days, there is also a way to start from calculation steps written in C or C++. A tool turns them into a circuit description like the one you would write in an HDL. This is called high-level synthesis (HLS).
CPU vs FPGA vs ASIC
A CPU has a fixed circuit and fetches and runs instructions one at a time. It can do any job, but it must fetch and decode an instruction every time. An FPGA runs as a circuit built for the job. For example, it can "multiply, add and compare" at the same time, each in its own circuit.
An ASIC is a chip designed for one job only and made in a factory. Built for the same job with the same generation of technology, an ASIC is usually the fastest and uses the least power. But before production starts, the design and the circuit master patterns (masks) cost a lot. You must make many chips to spread this cost thin enough to pay off.
| CPU | FPGA | ASIC | |
|---|---|---|---|
| What you can change later | The program | The circuit itself | Nothing |
| Efficiency at a fixed job (rough) | Lower | Medium | Highest |
| Cost to make the chip | None (off the shelf) | None (off the shelf) | Very high |
| Best for | Any job | Small volumes, changing specs | Large volumes, fixed specs |
"ASIC vs FPGA vs SoC" also has a table of the three, and how they relate to a chip that puts a whole system on one die (SoC).
Why is an FPGA slower and hungrier than a custom chip?
In an FPGA, every time a signal moves between logic blocks, it passes through many switches and long wires. An ASIC can link two points with the shortest wire. An FPGA must hop along the paths it already has. Also, even a small job like an AND may use a whole LUT with 64 boxes.
Researchers have measured this gap. Kuon and Rose of the University of Toronto built the same circuits as FPGAs and as ASICs, and reported the results in a 2007 paper. Both used the same generation of technology (90 nm). With only LUTs and flip-flops, the FPGA took about 35 times the area on average. Signals took about 3 to 4 times as long to pass through.
For power, they compared the part used when signals switch between 0 and 1 (dynamic power). The FPGA used about 14 times as much. With hard blocks, though, the area gap shrank to about 18 times. These numbers come from a generation nearly 20 years old, so today's products differ. But the reason is the same today: the ability to rewrite costs some efficiency.
Where are FPGAs used?
- Prototyping new chips: before an ASIC is made in a factory, the designed circuit is loaded into FPGAs. Real software is run on it to check it. Some very large FPGAs are made just for this use.
- Telecom equipment: communication standards keep being revised. Using FPGAs in cell towers and similar gear leaves room to fix the circuit after shipping.
- Test equipment and industrial machines: these are made in small numbers, so a custom chip does not pay off.
- Data centers: in a 2014 paper, Microsoft reported a trial that used FPGAs to speed up ranking for its Bing search engine. Each of 1,632 servers got one FPGA, and the work done per server rose by 95%.
- Space: on a satellite, a big plus is that the circuit can be rewritten from the ground after launch. In space, radiation can easily flip stored bits, an effect called a soft error. So special products built for space are used.
FPGA history and makers
The FPGA was invented by Ross Freeman, an American engineer. In 1984, he and his partners founded Xilinx to turn the idea into a product. In 1985, the company announced the XC2064, seen as the first FPGA. It had 64 logic parts inside.
For a long time, the two best-known FPGA makers were Xilinx and Altera.
- December 2015: Intel completed its purchase of Altera
- February 2022: AMD completed its purchase of Xilinx. Xilinx products are now sold as AMD products
- September 2025: the investment firm Silver Lake took a 51% stake in Altera. Altera is no longer an Intel subsidiary (Intel keeps 49%)
Other companies, such as Lattice and Microchip, also make FPGAs. The company relationships here are as of October 2026.
Common myths
Myth: An FPGA runs a program, like a CPU
In fact, a bitstream is not a list of instructions. It is a "circuit setting" that fixes the LUT contents and which switches are on or off. Once loaded, the circuit processes signals directly, and nothing fetches instructions. The exception is a product with a built-in CPU core, where that CPU runs programs. The shared word "program" is what causes the confusion.
Myth: An FPGA makes any task faster than a CPU
In fact, the tasks that speed up are those with many calculations that can run at once, in fixed steps. As we saw, signals take longer to pass through an FPGA's circuit. Its clock is usually slower than a CPU's. For tasks whose steps change a lot depending on conditions, a CPU is often faster. For huge amounts of multiplication, GPUs are also widely used ("Why Are GPUs Used for AI?").
Myth: Once you write an FPGA, it cannot be changed
In fact, most FPGAs can be rewritten any number of times by loading a different bitstream. SRAM-based products even reload their settings at every power-up. Still, a few products, such as some for space, can be written only once (the antifuse type).
By the numbers
| Item | Number |
|---|---|
| Logic parts in the first FPGA, the XC2064 (1985) | 64 |
| Size of AMD's Versal Premium VP1902 for prototyping (announced 2023) | 18.5 million logic cells |
| Gap between FPGA and ASIC (Kuon and Rose, 2007, 90 nm generation) | Area about 35×, delay about 3–4×, dynamic power about 14× |
A "logic cell" is a unit of size that each maker defines (AMD counts one 6-input LUT as 1.6 logic cells). It is counted differently from the XC2064's "64," so the two cannot be compared directly. Even so, it shows that FPGAs have grown by orders of magnitude in about 40 years.
Learn more
- See the differences in a table: Latch vs Flip-Flop, Static vs Dynamic Power
- Terms for your next step: FPGA (in-depth entry), RTL, STA (checking whether a circuit keeps up with the clock)
- Try it yourself: logic circuit simulator (build a gate's truth table to see what a LUT would store), setup and hold timing calculator (how circuit delay relates to clock speed)
- See it in a diagram: the setup and hold time diagram shows when a flip-flop takes in a value
- Related article: "What Is a Microcontroller?" (a small computer that runs a program, often compared with FPGAs)