How to choose an FPGA dev board in 2020. A comprehensive guide

Let's face it, It is not easy to choose a freaking PC these days with the deluge of specifications that come with it let alone FPGAs. The question of using FPGAs to solve any computing problem only arises when an extraordinary performance is required. Owing to this fact, FPGAs in their feature specification and build can be extremely specific to the application at hand. This results in an insane number of varieties in terms of the logic structures within the FPGA as well as the interfaces that are provided with the external world. However, this guide aims to guide you in the right direction (which does not mean dumping a list of the hundreds of different options out there) based on your level of experience and requirement.

There are other posts out there that provide large tables with exhaustive lists of FPGA development boards out there and let you (after a year or two of research) make a choice. If that's your thing, I'll attach some links to help you get started.

If you're already familiar with the various bells and whistles of FPGAs and are only looking for some good suggestions, you might prefer to JUMP TO THE LIST OF SUGGESTIONS. If not, read on to learn some very important stuff about the FPGA world and how to choose better!

What you should be looking for

There are already a lot of aspects to an FPGA in general that determine its fit to a particular problem and the ease with which it can be programmed, now add to this the complexity of a feature-rich development board with all sorts of peripherals, interfaces, connectors and memory options you have at hand a humongous task of deciding between hundreds of varieties out there.

SOC based board or just an FPGA?

SOC stands for System-on-Chip which simply means that various interacting technologies are built onto the same die (/chip). You see SOCs everywhere, on your phones, TVs, and computers. In the context of an FPGA development board, a SOC based system means that the hardware has two components, a sea of programmable logic (the FPGA) and a hard processor core implemented in silicon independent of the programmable FPGA logic. Interfaces are created between the programmable logic and the processing system (in Xilinx lingo) that enable communication between the two regions.


If you are an absolute beginner looking for direction, you should definitely choose a SOC based system because of the immense additional learning potential it adds. Having said that, your first few digital design projects should never involve the processor cores or any kind of software programming. For that, you can just ignore the processor logic and dump your design into the programmable region to use it as a normal FPGA. As you progress, you can add much higher levels of complexity to your design by bringing in the processor core to directly read and write data in your configurable hardware. You can also experiment with writing firmware, drivers, the Linux OS, and the higher levels of abstraction thus getting a truly holistic experience of embedded system design. Even the simplest SOC based board will keep you busy for a long time.

These boards can also be of great interest for Software engineers looking to explore into the digital design world since processor + FPGA structures lend themselves very well to paradigms like HLS, Heterogenous computing and partial acceleration of algorithms. Viewing the FPGA logic as an extension of the SOC is something that is going to be very important in the future and is a good investment of your time.

Alternatively, If you are a beginner but are looking only to learn digital design or you wish to buy a board to complement your studies at college where you get to use a particular board in your lab, you can get a lot more basic FPGA resources (LUTs, BRAMs, DSPs) on a Non-SOC based board that has only the FPGA. This way you save money and have a much less complex system at hand that you can comprehend better. The same is true If you plan to implement something specific that takes up an enormous number of resources, you might be better off going for a dev board that has only the FPGA and the required peripherals.

At the end of this post on the subreddit r/FPGA user u/ndbroadbent has shown the resource usages of several open source projects, this can give you a good idea of how big projects usually are.

An important note for beginners : Having an SOC board, with all the processor logic around the FPGA can really deviate you from the basic idea of programmable logic and how you're supposed to learn it. I strongly suggest completely disregarding anything to do with the processor for your first few projects and use only the FPGA part of the device. Also note that as of today, any good FPGA engineer will tell you that any form of HLS is not good enough to be used in real world projects. This is doubly true for the beginners. DO NOT fall into the 'Write code in C++/Python and run it on FPGA' trap. A lot of youtubers seem to be promoting stuff like that for beginners these days which is just sad. If you have the money to spend, the ideal (and more enjoyable) learning strategy would be to use a standalone FPGA board first and upgrade to an SOC later.

Interfaces and IOs:

FPGAs are excellent tools for working on high-speed interfaces. So you might want to look at the interfaces and IO options a particular development board is providing. This is important because if the board has a particular interface out of the box, the vendor will probably provide the necessary documentation and sample designs for those interfaces. This can save you tons of head-scratching and hair-pulling (trust me that is common in the FPGA world) as a beginner. That's not to say that newer interfaces cannot be added to the board manually but when it comes to High-speed interfaces like Ethernet, HDMI, PCIe, it can be very difficult to add them yourself and expect reliable performance. Low-speed ones like SPI, UART, etc can always be manually added using the GPIOs, so let them not be the dealbreaker for any board.

Some common networking interfaces that you should look for are high-speed interfaces like HDMI VGA ETHERNET PCIe etc. and low-speed peripherals like SPI CAN I2C etc.

Although not as important for a beginner, another set of interfaces that can be useful are the analog and sensor interfaces like ADCs, DACs, Camera Interface, Audio CODECs, etc. These are very niche features that can make or break a particular project if it depends on data acquisition from the external world.

If you choose to go for a board with not too many peripherals for whatever reason, you might be better off choosing one that has the industry-standard PMOD or FMC connectors installed so that when you do need additional interfaces in the future, they can be added very easily. These standard connectors essentially decouple FPGA carrier boards from the IO engines (which plug-in as daughter cards), enabling you to use the same FPGA boards with a large variety of IO designs without ever having to re-design the board.

Buttons, LEDs, and Displays:

Debugging FPGA designs can be a hard thing. Unlike MCUs where you can place print statements and breakpoints anywhere you want in the code, there is no such equivalent in the FPGA world and that can often lead to great frustration. One workaround is possible, if there are switches and LEDs on your board. They provide an easy way to pull out signals to the real world and give you an indication of the status of some status registers that can help you visualize and debug (like the current state of a state machine or a particular flag in a CPU design). However, this should not be the deciding factor between two boards since it is very easy to add LEDs, buttons, switches, and LCDs using the GPIO connectors without much effort.

Memory and Resource Count:

The Resource Count is another important metric that goes into deciding on an FPGA device. By resource, we mean the number of programmable logic elements available on the board. These can be LUTs (ALMs for Altera), Block Rams, DSPs, and IO blocks. Much more complex and fancier devices like the Versal family from Xilinx can have lots of other stuff like AI, video, and audio cores, etc. It is important to take note of these resource numbers because they determine the biggest project that you can successfully fit onto the FPGA. It is hard to come up with a fixed count for a particular project owing to differences in the underlying CLB architecture from vendor to vendor and family to family.

FPGAs store the configuration(bitstream) data on the SRAM (usually) cells within the FPGA. Since SRAM is a volatile kindof memory, the program is lost each time the board is power-cycled. A PC support is needed to reprogram it again after the power cycle, to prevent this, FLASH (or EEPROM in older boards) based storage is provided onboard by the vendors. Flash is a non-volatile form of storage that holds the bitstream data even without a power supply. Each time the board comes up after a power cycle, the FPGA checks the flash memory for a bitstream and programs itself with it. This is usually given by default in most boards but can be something important to look out for.

The other important form of memory is the external onboard volatile storage which is most commonly provided in the form of a DDR SDRAM This is extremely useful if you are building an application that needs to store data locally for whatever reason. Since the block ram storage within the FPGA fabric is very little and is very precious, having a DDR that can be written to and read from in a reasonable amount of time is very much essential. The more the better! This tutorial and this one can get you started with the interface that needs to be coded in order to communicate with the DDR chip.

Learning Resources and community support:

Unlike the world of software or MCU based design, the world of digital design and FPGAs have far fewer general resources in terms of quantity and no equivalent for stack overflow. If you are absolutely stuck on something, it could mean asking questions in random forums and hoping someone would have faced a similar problem or abandoning the project itself until you learn something that gets you out of the situation. As a beginner, it is always better to have the reference designs, board schematics, and learning guides supplied by the vendor or manufacturer of the development board.

- One example of a really good learning resource, not just for the board in particular but the SOC + FPGA ecosystem in general is The Zynq Book by Xilinx. Look out for such resources as they can make your life really really easy by providing quality information that is very hard to find via random google searches.

- Additionally, some boards and ecosystems have a richer community around them than others, for example, the DE10-Nano board has a large and ever-growing community around it owing to the MiSTer project that emulates a retro gaming console using this board.

The Toolchain:

This can be the dealbreaker decision for a lot of people since experienced people strongly prefer one set of tools over another. But for beginners, this is more of an ease-of-use based decision rather than affiliation to a particular company. Having said that the tools form Xilinx can be said to be better in some ways that those of Intel/Altera. For beginners, the Xilinx ecosystem overall has a plethora of Q&A forums, Whitepapers, and User Guides that always guide you to some form of help. The same cannot be said for the other toolchains.

Also, you get a lot of stuff from Xilinx For example, the MicroBlaze soft CPU is free, even the high-performance core, the high-level-synthesis is free, the logic probe analyzer is free, etc. etc. You really can go a long way with just the free Webpack software. The same cannot be said for the other ecosystems although alternatives and workarounds exist.

For the most part, Xilinx and Altera provide the same level of low-level control, it's just that Xilinx has a lot more high-level options available if you want them, but they can be ignored if you don't care about them.

The open-source EDA world too has made some considerable progress in recent times. Tool flows like ICEStorm have reverse engineered the architectures of some FPGAs and created toolchains that are much faster and in many ways better than the proprietary tools. The entire Icestorm toolchain weighs around 300MB or even less for the stripped version, compare that with the smallest Xilinx software (ISE - 16GB). This repo on Github seems to keep track of all these open-source tools for FPGAs. However, these tools will only work on certain FPGAs and boards mentioned in their docs. So do consider the downsides before choosing them.

One more thing to take care of is the support from the latest tools. For example, any FPGA below the 7-series in Xilinx is only supported by the now obsolete ISE tools. It's better to stay clear of such problems before hand.

Programming Interfaces:

There should be a way to transfer the final bitstream from your PC to the FPGA board. Several standards have been developed over time to assist this process. The most common ones are

  • JTAG
  • USB
  • SPI - Flash interface
  • Micro SD card

For beginners, always make sure that your board has a USB interface. Otherwise, you will be forced to spend money on a JTAG programmer. This article by Digilent explains all these programming methods in better detail. Further details on how to use the USB interface will be provided by the vendor.

PLLs, clock resources, and operating frequencies:

This is not something a beginner should be concerned with but it can be really important for experienced folks working on projects with specific requirements. clock resources can be very important especially for networking based projects that need to maintain very precise data rates and work with clocks recovered from the data itself. Operating and maximum frequencies significantly impact the energy profile ie. power consumption, heat dissipation, etc. of the final project.

Application-Specific Requirements:

Additionally, if you are buying a board to evaluate a particular FPGA for a specific application at hand, you should really dig into the specifications and see if it has exactly what you need. For example:

- Machine Learning, DSP, RF related projects need a lot of LUTs as well as DSP blocks for the MAC operations.

- Robotics, instrumentation, and Image-processing related projects could really use a SOC based system that lets you run regular software over your hardware right out of the box allowing you to make adjustments on-the-fly using something like an RTOS.

- Data Acquisition, real-time video processing, and Packet-based communication projects could require you to store large amounts of data locally needing larger DDRs and faster memory interfaces.

And finally, the biggest deciding factor for most people

Your Budget:

FPGAs are still quite expensive devices and resultantly create a larger barrier to entry for hobbyists and beginners in comparison to MCUs or software. So it's very important to find something that you can actually afford and be able to not cry when you burn a pin by making wrong connections. The $100-200 range is a pretty decent budget and will get you something that can keep you busy exploring for a long time. There are options that cost as low as $50 but you might have to compromise significantly on some or all of the criteria mentioned above.

The Top Contenders:

Following are the suggestions for beginners looking to get started with FPGAs. They have been listed after considering all of the parameters mentioned above. But most importantly, the boards providing the maximum variety of interfaces and user IOs for the lowest prices have been listed at the top. Support from the latest set of tools has also been considered. I have also mentioned the other contenders along with the reason I did not list them at the top. If those reasons do not matter to you, you should definitely consider them too.

As for the budget, the $100 to $300 range is the golden range for getting the best bang for your buck without spending big money. I'll mention expensive ones and cheaper ones after this list for those who might be interested in them.

I want an SOC based system.

The best SOC based FPGA development board under the $200 budget has to be the PYNQ - Z2 (/Z1) . Here's why:

  • The PYNQ boards provide an excellent collection of peripherals and a Zynq SOC along with a decent amount of programmable logic. There is nothing that it leaves us wishing and also does not blow a big hole in the wallet.
  • A very thorough and built-in integration between the python environment and the programmable logic. With all the jupyter notebooks and other things set up you'll get started in a breeze.
  • As already mentioned , the Zynq ecosystem that this board is based on is an extremely mature one, complete with everything from tutorials to complete books about the SOC based technology and its applications.
  • A bustling open-source community around the PYNQ project and lots of example projects and videos on youtube Here is a list of the features from their official website:


As you can see, the only difference between the PYNQ-Z1 and the PYNQ-Z2 is the audio codec and the headers. In both these aspects, the Z2 looks better but there isn't any fundamental difference betwee the two.

One more SOC based FPGA development board that stands out amongst the crowd is the Terasic DE-10 Nano. At $130 ($110 for academic) this board is literally the best deal you can ever get. Additionally, the very popular MiSTer project that emulates retro gaming console hardware using modern FPGA boards, is based completely on the DE10-Nano. This project is extremely popular among gaming and computer engineering enthusiasts and can be directly run on the board with almost no effort. Here are the specifications of the DE10-Nano:

de10nano1 de10nano2

The one and only reason for the DE10-Nano being mentioned second is that in my opinion, altera's tools, despite being just as powerful and mature as Xilinx's , might be a little bit harder for a beginner to use. The poor support documentation and community forums for these tools only adds to the problem. That being said, the DE10-Nano is different in terms of support owing to the MiSTer project as already mentioned. There's tons of tutorials out there for this particular board.

For example, in this comment u/sixtimesthree does an excellent job of listing everything you'll need to get started with this board along with the problems you might face and this link shows the plethora of compatible shields built for this board.

If you are really budget constrained and wish to save every buck you can, this board might as well be a better choice than the PYNQ!

Another SOC based board that I couldn't look away from was the Zturn board . It's excellent but the only problem I saw was the lack of a USB-JTAG programming interface. The only way to program it would be using a micro SD card or a JTAG programmer. If you're comfortable with that or you already own a JTAG programmer, you should definitely consider that board too.

If you (for whatever reason) wish to buy a board that doesn't have a lot of peripherals and leaves all the GPIOs to your discretion, do take a look at this mammoth Ultra96 . It gives you way more of everything and with the Zynq ultrascale architecture under the hood, it's way more powerful than anything else in the list. Definitely unnecessary for beginners tho.

I want just an FPGA and a lot of peripherals.

For this category, the Arty A7 from Digilent has to be the best of the bunch hands down. Here's why:

  • Tons of great peripherals and interfaces.
  • Lots of programmable logic cells
  • Supported by the latest toolchain from Xilinx with the free liscence (Vivado Webpack)
  • Garuntees external peripherals that readily interface with the PMOD connectors, owing to the fact that it is produced by Digilent.
  • An exhaustive list of support documentation and reference designs from Digilent coupled with a rich community around it. Here is the full spec list for the Arty A7. It comes in two varieties Arty A7-35T and Arty A7-100T . You could buy any one depending on your budget. You do not lose on any of the peripherals by choosing the cheaper one.

Arty A7

The other top contender for this category was the Basys 3 board. The only area where it was lacking is the absence of an ethernet interface.

But I can't afford to pay even 100 bucks!

Worry not. You still get to experience the amazingness of FPGAs. There are lots of cheap boards out there, but two of my favourites have to be the Cmod A7 from Digilent and the Alchitry Cu from Sparkfun. The Cmod A7 is supported by the latest set of tools from xilinx (most other cheap boards need the ISE toolset) and this board an be directly plugged onto a breadboard. At $75 it gives you a lot! Similarly the Alchitry Cu has some excellent connectors and the completely open-source ICEStorm toolchain supporting it.

But before you make your decision on a cheap board, do visit this excellent list of several boards out there. That should keep you busy for a while.

I would love to read about your opinions and ideas on these boards and also new board suggestions in the comments. Board review requests shall be joyfully accepted :)

Finally, compiling all the information in this list would not have been possible without the amazing community in the subreddit r/FPGA The next time you wish to discuss anything about FPGAs or just geek out on new information realted to this topic, you should definitely visit it.


I'm Batman, a silent nerd and a watchful engineer obsessed with great Technology. Get in touch via the Discord community for this site

Like what you are reading? Let me send the latest posts right to your inbox!

Free. No spam. Unsubscribe anytime you wish.