FPGA
Also known as: field-programmable gate array, programmable logic, VHDL, Verilog, HDL, reconfigurable hardware
An FPGA (Field-Programmable Gate Array) is a semiconductor chip that can be configured and reconfigured in the field (after manufacturing) to implement custom digital circuits.
Unlike a CPU (which executes software instructions in sequence) or an ASIC (Application-Specific Integrated Circuit, which is permanently wired for a specific function), an FPGA consists of a large array of programmable logic blocks and interconnects that can be configured to implement virtually any digital circuit. FPGAs offer hardware-level parallelism and low latency for specific tasks, making them valuable for networking hardware, signal processing, prototyping, and applications that need custom logic without the cost of manufacturing a dedicated ASIC.
FPGA, explained at three levels
At home
An FPGA is like programmable hardware -- you can tell it what circuit to be, and it becomes that circuit. Imagine LEGOs that can rearrange themselves to become a car, then a bridge, then a robot, based on instructions you give them. A normal chip (like a CPU) is a fixed design that runs software; you can only change what it does by writing different software. An FPGA's hardware logic itself can be reconfigured. This means you can use one FPGA to implement a custom networking chip, then reprogram it to be a video processing accelerator, then reprogram it again for a different task -- without manufacturing a new chip.
At work
FPGAs are used when you need hardware-level performance (faster than software on a CPU) but can't justify the cost and time of manufacturing a dedicated custom chip (ASIC). Key use cases: networking hardware (programmable network interface cards in data centers), signal processing (radar, software-defined radio), prototyping (testing chip designs before manufacturing), financial trading (ultra-low-latency order processing), and medical devices (real-time signal processing from sensors). FPGAs occupy a middle ground between flexible but slower CPUs and fast but inflexible ASICs -- giving customizable, high-performance logic without the multi-million-dollar cost of ASIC manufacturing.
At home
How FPGAs are programmed: FPGAs are configured using Hardware Description Languages (HDLs) -- primarily VHDL and Verilog. Unlike software programming (sequential instructions for a CPU), HDL programming describes parallel digital circuits: which logic gates exist, how they connect, and the timing relationships between signals. The HDL design is synthesized (compiled) into a bitstream that configures the FPGA's logic blocks and interconnects. High-Level Synthesis (HLS) tools (like Xilinx Vitis HLS) allow writing FPGA configurations in C/C++ and automatically generating HDL -- making FPGAs more accessible to software developers without HDL expertise.
At work
FPGAs vs. GPUs for accelerating workloads: GPUs excel at highly parallel, mathematically uniform workloads (matrix multiplication in ML training, graphics rendering) because they have thousands of identical floating-point units. FPGAs excel at workloads requiring: very low latency (FPGAs process data in deterministic clock cycles; GPUs have variable latency from scheduling overhead), custom data widths and formats (FPGAs can implement 7-bit or 13-bit arithmetic natively; GPUs work in 16/32/64-bit blocks), or complex control logic with variable dataflow. High-frequency trading, network packet processing, and certain inference workloads favor FPGAs; large-batch ML training favors GPUs.
At home
FPGA architecture internals: modern FPGAs contain several types of resources: LUTs (Look-Up Tables -- programmable logic functions that implement any boolean function of their inputs), flip-flops (registers for storing state), DSP blocks (dedicated multiplier-accumulator hardware for digital signal processing), block RAM (on-chip memory), and high-speed I/O transceivers (for PCIe, Ethernet, memory interfaces). The FPGA's programmable interconnect network routes signals between these resources. LUT count and DSP block count are the primary capacity metrics for FPGAs; a large FPGA (like Xilinx/AMD Virtex UltraScale+) may contain millions of LUTs and thousands of DSP blocks.
At work
FPGAs in cloud data centers: Microsoft's Project Catapult deployed FPGAs in Azure servers connected between the network interface and the CPU, processing network packets and ML inference in the FPGA fabric before data reaches the CPU. This architecture offloads latency-sensitive processing from CPU software to hardware, enabling software-defined networking functions (firewalls, routing, load balancing) to run at line rate without CPU overhead. AWS F1 instances expose entire Xilinx FPGAs (with 64GB of DDR4 memory and PCIe connection to the host) to customers, enabling custom hardware acceleration as a cloud service. Both approaches represent the convergence of programmable hardware and cloud-scale deployment.
Real-world examples
At home
Jerome built a home media server and wanted to transcode 4K videos faster without buying an expensive GPU. He found a used FPGA development board and programmed it to implement a hardware video decoder -- a fixed hardware pipeline that decoded video frames in parallel rather than sequentially in CPU software. The FPGA processed video 10x faster than the CPU for the specific codec he used, without drawing much power. When he upgraded to a different codec, he reprogrammed the FPGA's logic for the new format -- something he couldn't do with a fixed-function hardware decoder chip.
At work
Nadia was designing a high-frequency trading system that needed to execute trades within 10 microseconds of receiving market data. A software solution on a CPU was too slow due to operating system scheduling overhead and software instruction latency. She implemented the order routing logic on an FPGA connected directly to the network: the FPGA received market data, evaluated trading rules implemented in hardware logic, and sent orders in under 1 microsecond from data receipt -- far below the 10-microsecond target. The FPGA's deterministic, hardware-implemented logic provided the latency guarantee that no software solution could match.
Common confusions
- Many people confuse FPGAs with ASICs, assuming they serve the same purpose — FPGAs and ASICs both implement custom digital circuits, but through fundamentally different approaches. An ASIC is a chip manufactured with permanent custom circuitry -- highly optimized, very fast, and very power-efficient for its specific function, but expensive ($1M+ for design and manufacturing of advanced ASICs) and inflexible (once manufactured, the circuit cannot change). An FPGA is a general programmable chip that is configured (not manufactured) for a specific circuit -- more flexible (reconfigurable), faster to deploy (no manufacturing lead time), lower upfront cost, but less optimized in performance and power than a purpose-built ASIC doing the same task. FPGAs are often used to prototype ASIC designs or as production hardware when volumes are too low to justify ASIC manufacturing.
- Some assume FPGAs are mainly a prototyping tool and not suitable for production systems — FPGAs are widely deployed in high-volume production systems across multiple industries: modern network switches and routers contain FPGAs; data center network interface cards (SmartNICs) use FPGAs; military and aerospace systems rely on FPGAs for their radiation tolerance and reconfigurability; software-defined radio systems use FPGAs for signal processing; and cloud providers (Microsoft, AWS) deploy FPGAs at data center scale. The reconfigurability that makes FPGAs useful for prototyping also makes them valuable in production for applications where the hardware logic needs to be updated without replacing the physical hardware -- network protocol updates, new signal processing algorithms, or evolving hardware acceleration requirements.
For analysts
FPGA knowledge is most relevant for clients in industries where custom hardware performance is a competitive differentiator: financial services (ultra-low-latency trading infrastructure), telecommunications (network equipment, software-defined networking), defense and aerospace, signal processing (medical imaging, radar, industrial sensing), and cloud providers building custom hardware acceleration. When assessing technology options for these clients, understanding that FPGAs occupy the space between general-purpose CPUs and dedicated ASICs -- offering custom logic performance with deployment flexibility -- helps frame the build vs. buy decision for custom hardware acceleration components.
History & origin
The FPGA was invented by Ross Freeman and Bernard Vonderschmitt, co-founders of Xilinx, in 1984. Early FPGAs were used primarily for rapid prototyping of digital circuits before committing to ASIC manufacturing. As FPGAs grew in capacity and speed through the 1990s-2000s, they became production hardware in networking equipment, telecommunications, military systems, and test equipment. Altera (later acquired by Intel) and Xilinx (later acquired by AMD) dominated the FPGA market. In the 2010s, cloud computing discovered FPGAs: Microsoft deployed FPGAs in Azure data centers for Bing search acceleration (Project Catapult), and AWS introduced F1 instances with Xilinx FPGAs for custom hardware acceleration. Intel and Xilinx introduced FPGAs with integrated ARM processors (SoC FPGAs), blurring the line between programmable logic and general-purpose computing.