Imagine a chip that isn't built for one job — a chip you can rewire into a video processor in the morning, a network packet filter in the afternoon, and an AI accelerator by evening, all without ever visiting a factory. That chip exists. It's called an FPGA, and over the next lessons you'll learn to design real hardware on one. Let's start with the big idea.
FPGA stands for Field-Programmable Gate Array. Break that name down and you already understand it:
Here's the mind-bending part. With a normal processor you write software that runs on fixed hardware. With an FPGA you describe a digital circuit, and the chip physically becomes that circuit. You're not writing instructions for a CPU to execute — you're defining the wiring of the silicon itself. Want a different circuit? Load a different configuration and the same chip transforms into something completely new.
The fastest way to "get" an FPGA is to compare it to the chips you already know:
| Chip | How it works | Strength | Weakness |
|---|---|---|---|
| CPU | runs a fixed instruction set, mostly sequentially | flexible, easy to program | limited parallelism |
| GPU | thousands of cores doing the same op on lots of data | massive data parallelism | power-hungry; fixed architecture |
| FPGA | reconfigurable logic wired into a custom circuit | custom parallel hardware, deterministic timing | harder to design; lower clock speed |
| ASIC | logic permanently fabricated for one job | fastest, lowest power | huge cost; cannot be changed |
The key distinction: a CPU and GPU have a fixed architecture and you adapt your problem to them in software. An FPGA has no fixed architecture — you adapt the hardware to your problem. If your task maps to, say, 500 little processing units all running at once, an FPGA can literally build those 500 units in parallel. (If you've explored our CPU vs GPU vs TPU vs NPU guide, the FPGA is the "build-your-own-architecture" option.)
So how does a generic chip turn into your circuit? Through a configuration file called a bitstream. The journey looks like this (we'll go deep on it in Day 4):
The bitstream is just a big pattern of 1s and 0s that sets every configurable element inside the FPGA. Load bitstream A and the chip is a UART; load bitstream B and it's a digital filter. The hardware is the same — the configuration is everything.
We'll spend the next two lessons here, but the preview: an FPGA is a vast sea of small, configurable pieces connected by a programmable wiring network:
Combine thousands to millions of these and you can build almost any digital system you can describe.
FPGAs are everywhere demanding, custom, or fast-changing digital work happens:
FPGAs and ASICs both implement custom digital logic, so when do you pick which? It comes down to cost, volume and performance:
| FPGA | ASIC | |
|---|---|---|
| Up-front cost (NRE) | low / none | millions ($) |
| Per-unit cost | higher | very low at volume |
| Performance / power | good | best |
| Changeable after build? | yes — reprogram | no — fixed forever |
| Time to working hardware | hours/days | months |
| Best for | prototyping, low–mid volume, evolving specs | very high volume, fixed function |
Rule of thumb: FPGA when flexibility, time-to-market or low volume matter; ASIC when you're shipping millions of identical units and can amortise that enormous fabrication cost. Many products even start life on an FPGA and graduate to an ASIC once the design is proven and volumes justify it. (For the chip-fabrication side of ASICs, see our VLSI design flow.)
An ASIC is a plastic toy injection-moulded in a factory: perfect, cheap in bulk, but the mould costs a fortune and the shape is fixed forever. An FPGA is a giant box of LEGO: you can build almost anything, take it apart, and rebuild it differently tomorrow. It's a little bigger and slower than the moulded toy — but you can start right now, with no factory.
You don't need to know brands to learn the concepts, but it helps to recognise the landscape:
For learning, an inexpensive development board (e.g. a Basys 3, Arty, Tang Nano, or an iCE40 board) gives you LEDs, switches and I/O to run your designs on real silicon. There's also a thriving open-source toolchain (Yosys + nextpnr) for Lattice parts — and you can practise the HDL side right now, in your browser with our online Verilog simulator before you ever buy a board.
An FPGA is a chip full of reconfigurable logic (LUTs, flip-flops, routing, hard blocks) that you wire into a custom digital circuit by loading a bitstream. Unlike a CPU/GPU you change the hardware, not just the software; unlike an ASIC you can reprogram it with no fabrication cost. It's the perfect tool for parallel, custom, low-latency or fast-evolving hardware — and the perfect way to learn digital design hands-on.
A Field-Programmable Gate Array — a chip whose digital logic you can reconfigure after manufacturing into any custom circuit you describe.
A CPU runs software on fixed hardware; an FPGA lets you build the hardware itself as a custom parallel circuit.
ASICs are faster and cheaper at huge volume but cost millions and can't change; FPGAs are reprogrammable with no fabrication cost, ideal for prototyping and low-to-mid volume.
The configuration file that sets every LUT, flip-flop and routing switch, turning the blank FPGA into your designed circuit.
Yes — you describe FPGA hardware in Verilog or VHDL. Basic Verilog is enough to start, and this course introduces it gradually.
← Back to the full course roadmap · Try the online Verilog simulator →