What Is an FPGA? A Plain-English Explanation
An FPGA — field programmable gate array — is a type of integrated circuit that you can program, erase, and reprogram after it has been manufactured. Unlike a standard chip that arrives with fixed behavior, an FPGA starts as a blank slate and becomes whatever digital circuit you define. That flexibility is the entire point.
The word “field” in the name just means “in the field” — as in, at the customer’s location, not back at the factory. You ship the hardware, then configure it on-site for the exact task at hand.
Key Takeaways
- An FPGA is a blank-slate integrated circuit you program with hardware description languages like VHDL or Verilog
- It can mimic a processor, a graphics card, a custom accelerator, or nearly any other digital circuit
- The global FPGA market was valued at $9.8 billion in 2020 and is projected to reach $23.34 billion by 2030
- Major industry players include AMD (via its 2022 acquisition of Xilinx for approximately $50 billion) and Intel (which acquired Altera for $16.7 billion in 2015, which re-independent as Altera in 2024)
- FPGAs dominate applications where reprogrammability matters more than raw cost: telecom, defense, medical imaging, AI acceleration, and high-frequency trading
How Does an FPGA Work?
At its core, an FPGA is a grid of tiny, configurable logic blocks — called CLBs (configurable logic blocks) or LABs (logic array blocks) depending on the vendor — connected by a network of programmable routing wires. You control what each block does and how the blocks connect to each other.
The most common logic element inside a block is a lookup table (LUT) — a small memory that acts as a truth table for a digital logic function. A typical LUT holds 4 inputs and can represent any 4-input Boolean logic function. Chain LUTs together, and you can build up arbitrarily complex digital circuits.
Each logic block also typically contains a D-type flip-flop — a memory element that holds one bit of state on each clock cycle. Between the LUTs doing the computation and the flip-flops holding state, you have everything you need to build processors, signal processors, protocol converters, or anything else.
What makes an FPGA different from a fixed chip is the programming model. You describe the circuit you want using a hardware description language (HDL). The two most common are VHDL and Verilog. Verilog looks and feels a bit like C, which makes it easier to pick up for software developers. VHDL is more verbose but more explicit. Both compile down to a bitstream — a binary file that gets loaded onto the FPGA to configure its LUTs, flip-flops, and routing switches.
You load that bitstream over a USB or Ethernet cable connected to a JTAG programmer, or from an external EEPROM or flash memory chip each time the board powers on. Most modern FPGAs are SRAM-based, which means they lose their configuration when power is removed — so the external memory chip reloads the bitstream on every boot.
A 2006 study by Kuon and Rose at the University of Toronto put concrete numbers on the tradeoff: compared to a custom ASIC (application-specific integrated circuit), an equivalent FPGA design requires roughly 40 times more chip area, draws about 12 times more dynamic power, and runs at roughly one-third the clock speed. The payoff is reprogrammability — you can fix bugs, change the function, or pivot the application without respinning a $5 million chip mask set.
FPGA Architecture: Inside the Box
Modern high-end FPGAs are not just a sea of LUTs. They pack a range of hardened, application-specific blocks alongside the programmable fabric:
- DSP slices: dedicated multipliers and accumulators for signal processing — far more efficient than building multiplication out of LUTs
- Block RAM (BRAM): embedded memory blocks for storing data or buffering signals
- Transceivers: multi-gigabit SerDes (serializer/deserializer) blocks for high-speed communication at 28 Gbit/s or more
- Hard processor cores: some FPGAs — like the Xilinx Zynq-7000 — embed ARM Cortex-A9 cores directly in the silicon alongside the programmable fabric, so you get a CPU and an FPGA on the same chip
- PLL/DLL: clock generation and management circuits
That last point matters more than it sounds. Most digital circuits are synchronous — they run on a clock. FPGAs include dedicated clock management networks (typically an H-tree topology) to distribute clock signals across the chip with minimal skew, plus analog PLLs to synthesize new frequencies from a reference clock. Complex designs use multiple clock domains — different parts of the chip running at different speeds — and crossing between those domains requires careful design.
A 2012 architectural milestone brought FPGAs closer to true system-on-chip territory. The Xilinx Zynq-7000 integrated a 1.0 GHz dual-core ARM Cortex-A9 alongside the FPGA fabric. The Altera Arria V did the same with 800 MHz dual-core ARM Cortex-A9 cores. These are called SoC FPGAs or all-programmable SoCs, and they handle both the software stack (running Linux or an RTOS on the ARM cores) and the hardware acceleration (custom logic on the FPGA side) on one piece of silicon.
How Do You Program an FPGA?
The typical FPGA development flow looks like this:
- Write HDL — describe the desired circuit in VHDL or Verilog. You can also use schematic entry for small designs, but HDL scales better.
- Simulate — test the design in a virtual environment with test benches before touching any hardware.
- Synthesize — the EDA tool (Vivado for Xilinx/AMD, Quartus for Intel/Altera, Diamond for Lattice) converts the HDL into a technology-mapped netlist of actual FPGA resources.
- Place and route — the tool decides which LUT goes where on the chip and how the routing wires are connected.
- Generate bitstream — produce the binary configuration file.
- Program the device — load the bitstream over JTAG or store it in flash for automatic loading at power-on.
A useful shortcut exists for certain workloads: OpenCL. Rather than writing HDL directly, you write C code with OpenCL, and a high-level synthesis tool converts it to HDL. This lowers the barrier for software programmers to use FPGAs for parallel acceleration tasks. It is not a replacement for deep HDL work when maximum performance matters, but it gets you to working hardware faster.
FPGA Applications: Where FPGAs Show Up
An FPGA can become any digital circuit, so the applications list is long. The places where they are most common:
Telecommunications and networking. FPGAs handle protocol conversion, signal processing, and base station hardware in 4G and 5G infrastructure. Their parallel processing ability and reprogrammability make them ideal for a standards environment that keeps evolving.
Defense and aerospace. Radiation-hardened FPGAs are standard in satellite and military communications systems. The reprogrammability means a system deployed overseas can be updated without physical access. FPGAs play a role in the Joint Tactical Radio System (JTRS), providing adaptable signal processing for military comms.
Medical imaging. FPGA-based systems handle 3D MRI image segmentation, tomographic reconstruction, and PET/MRI fusion. The combination of parallel processing speed and real-time determinism — the circuit responds in a known number of clock cycles — is critical in clinical environments.
AI and machine learning acceleration. FPGAs have become a mainstream AI inference platform. Microsoft deployed them in its Bing search data centers starting in 2014 (Project Catapult), and the approach extended to Azure. The advantage over GPUs for certain inference tasks is better power efficiency per watt. Since 2019, FPGAs have been integrated with AI engine tiles — dedicated matrix multiplication hardware — targeting the AI inference market directly.
High-frequency trading. The deterministic, low-latency nature of FPGA-based trading systems means a circuit can react to market data in nanoseconds. Multiple quantitative trading firms use custom FPGA accelerators for this reason.
ASIC prototyping. Before committing to a multi-million dollar ASIC fabrication run, companies prototype their design on an FPGA. The logic is the same; the FPGA just runs slower and costs more per unit. This is still one of the most common uses for FPGAs in semiconductor companies.
Retrocomputing and hobbyist projects. Projects like the MiSTer FPGA recreates classic computers and game consoles at the circuit level — not emulated in software, but implemented as an actual hardware design running on an FPGA.
FPGA vs. Other Options
The most common comparison is FPGA versus microcontroller (MCU). A microcontroller runs software instructions sequentially on a fixed CPU. An FPGA runs hardware circuits in parallel. If your problem fits in a microcontroller’s fixed CPU model, an MCU is cheaper and easier to program. If you need to process multiple data streams simultaneously, or if the fixed CPU instruction set is a bottleneck, an FPGA’s parallel architecture can outperform a much faster microcontroller.
Against GPUs, the tradeoff is power efficiency versus raw throughput. A GPU excels at running thousands of identical operations in parallel on large datasets. An FPGA is better suited to irregular, latency-sensitive tasks where the exact data path matters. For inference workloads with strict power budgets — edge devices, embedded systems — FPGAs often outperform GPUs on a performance-per-watt basis.
Against ASICs, the FPGA’s single advantage is reprogrammability. ASICs are always faster, smaller, and more power-efficient for a given function. But ASICs carry enormous non-recurring engineering (NRE) costs — a mask set for a modern process node can run $5–50 million. FPGAs cost more per unit, but the NRE is essentially zero. For production volumes below a certain threshold (depending on complexity, roughly below 10,000–100,000 units), FPGAs are cheaper overall.
Major Players and the Market
The FPGA market has a clear hierarchy. In 2016, Xilinx and Altera together controlled roughly 90% of the market. That structure changed dramatically through acquisitions:
- 2015: Intel acquired Altera for approximately $16.7 billion — Intel’s largest acquisition at the time.
- 2020–2022: AMD acquired Xilinx for an estimated $50 billion, completing in February 2022. AMD renamed the unit AMD Adaptive and Embedded Computing.
- 2024: Altera re-independent from Intel, operating as a standalone FPGA company again.
The remaining market is distributed among Lattice Semiconductor (focused on low-power, low-cost FPGAs), Microchip (via its acquisition of Microsemi/Actel), and GOWIN Semiconductor. QuickLogic focuses on ultra-low-power sensor hub applications.
Lattice Semiconductor’s value proposition centers on instant-on capability and live reconfiguration — their FPGAs store their configuration in internal flash, so they start operating the moment power is applied without waiting for an external memory load.
FPGAs and AI: The Current Moment
The most active area of FPGA development in 2024–2026 is AI inference acceleration. The integration of AI engine tiles — dedicated matrix multiplication blocks — alongside traditional FPGA fabric allows these devices to compete directly with purpose-built AI accelerators for certain inference workloads.
The attraction for AI inference is a combination of factors: parallelism comparable to GPUs, lower power consumption, deterministic latency, and the ability to update the inference model without hardware replacement. As AI deployments move from cloud to edge — industrial cameras, autonomous vehicles, edge servers — FPGAs’ power efficiency and flexibility become more attractive relative to GPU solutions that were designed for batch processing in data centers.
Final Thoughts
An FPGA is a programmable blank slate. At its simplest, think of it as a box of LEGO bricks that can become any digital circuit you can imagine — a processor, a graphics card, a signal processor, a protocol translator — and then become something else entirely when your requirements change. The cost is power and speed compared to a custom chip: roughly 40 times more area, 12 times more power draw, and one-third the clock rate, according to a 2006 University of Toronto study.
That tradeoff makes sense when reprogrammability has economic value: prototyping ASICs, adapting to evolving telecom standards, running AI inference at the edge, or any application where the cost of respinning a fixed chip outweighs the power penalty of using an FPGA.
If you are coming from a software background, the idea of “programming hardware” can feel abstract. But the development tools have matured significantly — OpenCL support means you do not need to write HDL to get an FPGA running. And if you do go down the HDL path, starting with Verilog is closer to what you already know.
The market numbers tell you something about how seriously the industry takes FPGAs: from $14 million in 1987 to $9.8 billion in 2020, on a trajectory to $23.34 billion by 2030. The $50 billion AMD paid for Xilinx in 2022 was not a bet on a shrinking technology.
