Recommend FPGA SoC & Dev Board to get started

[Paul1990]

Hello everyone,

I am an electronics & embedded systems engineer with some experience in pcb design and firmware development.

I have ever worked with microcontrollers and SBCs but I am not familiar with FPGAs and hybrid SoCs like Zynq.

So I would like to know your opinion which is best & easiest way to learn FPGAs.

I need rich study data & cheap dev board to get started.

Looking forward to hearing extensively.

Regards,
Paul

[cfbsoftware]

We were in the same position as you more than a decade ago. Hands-on experience working with, and modifying, non-trivial systems have proven to be the best way for ourselves to learn.

Originally we started with Project Oberon 2013 developed by Prof Niklaus Wirth (of Pascal, Modula-2 and Oberon fame) assisted by Paul Reed. This is implemented on a Digilent Xilinx Spartan-3 Development board and results in an entire windowing operating system, development tools and a programmer's workstation. The included detailed documentation describes the design and implementation of the entire system. This proved to be invaluable.

Once we had learnt how this all hangs together and had acquired the necessary Verilog FPGA development skills to make changes to it, we adopted the experience we had gained developing software tools for Arm MCUs to get us where we are today with our Oberon for RISC5 (Note: NOT RISC-V) bare-metal software system. It is described here:

https://www.astrobe.com/RISC5/

Differences from the original Project Oberon system are summarised here:

https://www.astrobe.com/RISC5/differences.htm

[Berni]

Dev boards for FPGAs are a lot less important than one might think.

When doing MCUs of Linux SoCs you always test your stuff on real hardware, hence having a dev board is vital for doing anything. However in the FPGA world only a fraction of testing is performed on real hardware. The FPGAs are just so annoying to compile for and debug that most of the testing is performed within a simulator. Every major FPGA software package will include some form of HDL simulator that has specific support for that vendors chips.

So choose the vendor you like (Altera, Xilinx, Lattice..etc) since you will be forced to use their compiler, then grab a cheap board for their latest FPGA family in a decent sized chip (avoid the smallest chips they make, but don't buy any of the huge expensive chips). You mostly just need a board that has a bunch of LEDs, a few buttons and lots of IO pins brought out to a pin header. Some ports like VGA can be useful (FPGAs are good at video and is simple) but things like PS2 USB audio...etc are usually not useful.

Getting that LED blink on real hardware is certainly a good dopamine rush to motivate you to learn more, but as soon as your designs get bigger and more complicated, testing on real hardware becomes just an annoyance. Compiling the code might take 10 minutes then once you load it and run it, there is no 'debugger' to single step trough your code and look at state. You can't stop logic gates. The design runs at full speed all the time, all you can do is observe the IO pins. Hence every signal you want to see has to be brought out to a IO pin (another 10 minute compile) or routed to a logic analyzer implemented in FPGA logic (another 10 minute compile and eats a lot of FPGA resources). This is not fun when you are hunting down a nasty bug.

This is why HDL simulators exist. They are able to recompile just 1 changed source file in <1 second and also give you the ability to freeze the whole world at any point, letting you inspect every signal in the design at the click of a mouse. This makes iteration and fault finding much MUCH faster. Hence this is where HDL designers spend most of their time. This is very similar to the "test driven development" principle in software where you build modular code and slot each model into a test bench to exercise it and verify if its behavior is correct. This does mean you have to also write a test bench to simulate the rest of the system, but with the age of AI you can have the AI write most of that for you.

So before you buy it might be a good idea to just download the IDE from your preferred vendor and try to blink a IO line in a simulator. Once you buy a vendors chip you will be locked into using their IDE.

[gbyleveldt]

The absolute cheapest way is the old Zynq mining boards on AliExpress. Used to be cheaper but can still be had for ~$20; they even have breakouts for similar prices.

More details here:

https://github.com/xjtuecho/EBAZ4205

[zapta]

I started with the Upduino and was very happy with it. You can also look for cheap chinese FPGA boards such as Sipeed Tang Nano (they come in different sizes). I like dev boards that can be plugged in solderless proto boards because it's easy to experiment with them.

https://tinyvision.ai/products/fpga-development-board-upduino-v3-1

For development software I used the open source and free Apio (it has two variants, for command line and for Visual Studio Code IDE, both are easy to install and use) and even contributed code to it.

[zapta]

Once you buy a vendors chip you will be locked into using their IDE.

Unless if you use an open source suite such as Apio (IDE and command line) which currently supports FPGAs from three vendors.

[SamElectronics616]

I would recommend starting with a simple and affordable board, such as the ZynqBerry Zero.

In general, a Zynq SoC would be a good fit for your project because it combines an ARM processor with FPGA capabilities in a single device.

Rather than starting with a complex and expensive development board, I think a lower-cost board with the basic I/O interfaces you need would be more practical and effective for initial development and testing.

[asmi]

I would recommend starting with a simple and affordable board, such as the ZynqBerry Zero.

In general, a Zynq SoC would be a good fit for your project because it combines an ARM processor with FPGA capabilities in a single device.

Rather than starting with a complex and expensive development board, I think a lower-cost board with the basic I/O interfaces you need would be more practical and effective for initial development and testing.

Such a weird recommendation. Zynq by itself is a quite complex and definitely not a beginner-friendly device. IMHO it's best to get started with "pure" FPGA device without additional complexities which presence of PS implies. Also stay away from obscure boards from ebay/aliexpress, a lot of those were designed by idiots who don't really know what they are doing, and as a result those PCBs tend to come with underspecced PDS, insufficient (or nonexistent) thermal management, and a zero vendor support - and random hardware failures is the last thing a beginner needs while he is still not completely understands what he is doing and so he is absolutely in no position do diagnose these HW problems - so a few saved bucks might end up costing much more in time spend banging your head against the wall. I'd highly recommend to buy a board from a reputable vendor who stands behind its products and does provide help and support, for example like Digilent in case of AMD devices, which has forums staffed by support people who were helping beginners for many years and often provide very useful guidance.

[asmi]

Unless if you use an open source suite such as Apio (IDE and command line) which currently supports FPGAs from three vendors.

Until these tools properly support timing analysis, they are only good in a very limited scenarios and generally can not be relied upon for anything where there is even remote possibility that timing might become a problem.

[SiliconWizard]

Yes, I would not recommend those open-source tools to a beginner. Timing analysis is limited, but timing constraints are even more so: last I checked, you could not define anything more than a global target frequency. Maybe it has improved since.

But a beginner needs tools that they can fully rely on, and also that they'll learn more with. Because even if said beginner only starts with relatively simple and "low-frequency" stuff that will "just work" without any advanced timing constraints, they will not learn how to properly define said constraints, and it's an important skill to learn for FPGA and more generally digital design.

IMHO, those open-source tools are interesting for more experienced people that really want to help improving those tools, or if they absolutely insist on using open-source tools only, but they need to know what they are working with quite well, otherwise they're in for a rough ride.

[cfbsoftware]

Yes, I would not recommend those open-source tools to a beginner.

What would you recommend to a beginner? Not Vivado I hope?

[Berni]

Honestly all of the FPGA tools are terrible.

The open source tools are too basic for real work and most of them are built from reverse engineering, since vendors keep the inner workings of their FPGA chips a secret. Good timing analysis capabilities are absolutely vital once the designs run at any sort of speed. Only the vendor that made the chip has the intimate knowledge of how to account for the delay of every trace and crossbar switch in the chip. Not even talking about getting the more complex blocks in FPGAs set up like a DDR memory controller.

The official vendor tools are great then right?
Well...
Yes they are very capable, but they are far from intuitive to use. You need to read documentation or guides to get anything done and the next time you pick them up after a few years you will again have to read up on how to actually use it. A lot of these are tools that have been built on top of legacy crud for many decades. Heck to the point where they tell you to not use spaces in your file paths. Since "Program Files" has a space in it they instead install themselves by default directly into a folder on the C: drive. Yes in 2026 we still can't handle spaces properly.

From my experience the tools from Xilinx tend to be the more modernized ones.

But for a HDL code editor VSCode with the Sigasi HDL plugin works great. It gives VSCode all of the proper code edit, traversal, intelisense..etc capabilities that you get from C code. It also has block diagram visualization features to help you make sense of larger source files (as all HDL languages are horribly unreadable). Then you mostly just go back to the vendor tools to compile or simulate the design.

EDIT: Oh and do not use ARM+FPGA SoC chips. They are always overly complicated for what they do. You can get by perfectly fine by taking your favorite MCU family (STM,LPC,ESP..etc) and connect a memory bus onto any FPGA. This gives you most of the way to what a ARM+FPGA chip is, but with much more freedom in chip and architecture selection.

[zapta]

Hi Paul,

I was in your situation 2-3 years ago, some background in electronics and software but none with FPGA. When I examined my options I ended up getting an inexpensive FPGA board (Lattice ICE40 based Upduino) that I could plug into a solderless breadboard for experimentation and program with with the free and open source Apio 0.96. I chose Apio because its is lack of license hassle, and the ease of installing and using it on mac/linux/windows, especially for beginners like me (Apio inherited its easy of use from Platformio which was the inspiration for Apio). Since then Apio got even better and easier to use (some are my contributions) and now it has also full IDE support via the VSCode 'apio' extension.

My advice to you is to give it a try even before you buy any board, install it (my preference is in VSCode but the command line option is also very good), try a few of the examples (e.g. of the Alhambra II board), look at the project code, modify it, run tests and interactive simulations and see that you can get the code to do what you want, and go from there. You can go a very long way without any board.

Apio extension for VSCode: https://marketplace.visualstudio.com/items?itemName=fpgawars.apio

And if you prefer a plain command line instead of VScode: https://fpgawars.github.io/apio/docs/quick-start/

[SiliconWizard]

Yes, I would not recommend those open-source tools to a beginner.

What would you recommend to a beginner? Not Vivado I hope?

I'm sure this is workable with some effort and tutorials. But I'm not ultra fond of Vivado myself. ISE was IMO easier to use, and that's actually what I began with. (First FPGA was a Spartan 3.)

What I'd recommend in general for beginning with FPGAs hasn't much changed: Lattice. Their tools are IMO the easiest to use and are reasonably fast. Both Diamond and Radiant.
They also used to have pretty cheap dev boards, they have bumped up their prices a while ago though, but one can still find dev boards at reasonable prices. The MachXO2 or XO3 are IMO good for starting, otherwise I'd recommend the iCE40UP (supported by Radiant) which doesn't have many IOs but is otherwise simple enough and rather ideal for beginners. It's also inexpensive. (People can start with the Upduino boards.) Just my 2 cents.

[nctnico]

Honestly all of the FPGA tools are terrible.

The open source tools are too basic for real work and most of them are built from reverse engineering, since vendors keep the inner workings of their FPGA chips a secret. Good timing analysis capabilities are absolutely vital once the designs run at any sort of speed. Only the vendor that made the chip has the intimate knowledge of how to account for the delay of every trace and crossbar switch in the chip. Not even talking about getting the more complex blocks in FPGAs set up like a DDR memory controller.

The official vendor tools are great then right?
Well...
Yes they are very capable, but they are far from intuitive to use. You need to read documentation or guides to get anything done and the next time you pick them up after a few years you will again have to read up on how to actually use it. A lot of these are tools that have been built on top of legacy crud for many decades. Heck to the point where they tell you to not use spaces in your file paths. Since "Program Files" has a space in it they instead install themselves by default directly into a folder on the C: drive. Yes in 2026 we still can't handle spaces properly.

From my experience the tools from Xilinx tend to be the more modernized ones.

But for a HDL code editor VSCode with the Sigasi HDL plugin works great. It gives VSCode all of the proper code edit, traversal, intelisense..etc capabilities that you get from C code. It also has block diagram visualization features to help you make sense of larger source files (as all HDL languages are horribly unreadable). Then you mostly just go back to the vendor tools to compile or simulate the design.

I second going this route as well. I'm using Eclipse with the Veditor plugin to edit HDL. AFAIK other (better) plugins exist for VS Code. Last time I checked Sigasi (for Eclipse) costs serious money but it works well.

Where it comes to the vendor FPGA tools: I find the tools from Gowin pretty easy to get going. But I hit another low with Libero from Microchip. That is pretty bad.

[nctnico]

Getting that LED blink on real hardware is certainly a good dopamine rush to motivate you to learn more, but as soon as your designs get bigger and more complicated, testing on real hardware becomes just an annoyance. Compiling the code might take 10 minutes then once you load it and run it, there is no 'debugger' to single step trough your code and look at state. You can't stop logic gates. The design runs at full speed all the time, all you can do is observe the IO pins. Hence every signal you want to see has to be brought out to a IO pin (another 10 minute compile) or routed to a logic analyzer implemented in FPGA logic (another 10 minute compile and eats a lot of FPGA resources). This is not fun when you are hunting down a nasty bug.

In my FPGA designs I typically have a debug bus inside which can expose 8 to 16 internal signals onto a header. I set the timing limits long so it doesn't impact routing. Over the decades this approach has worked really well for me. I can select signals from about any module on the fly and inspect with an MSO or logic analyser. It allows to search for problems when an FPGA is integrated into a bigger system where standalone simulation just doesn't cover enough ground.

[Berni]

Yep i always bring out extra IO from FPGAs on my devboard for a logic analyzer connection.

My favorite for that are Hirose DF40 connectors as they are very small for the number of pins. Tho it does need the mating part soldered to a flex PCB to reduce the strain on such a tiny connector.

[cfbsoftware]

What would you recommend to a beginner? Not Vivado I hope?

I'm sure this is workable with some effort and tutorials. But I'm not ultra fond of Vivado myself. ISE was IMO easier to use, and that's actually what I began with. (First FPGA was a Spartan 3.)

We also started with ISE and Spartan-3. It is not that Vivado is particularly difficult to learn how to use - the problem is that it is a sluggish 10 GB monstrosity. We have found compile times to be 10x faster with the open source tools. That wouldn't be so bad if Vivado compile times were measured in seconds but when it takes 10 minutes instead of 1 minute productivity goes out of the window.

What I'd recommend in general for beginning with FPGAs hasn't much changed: Lattice. Their tools are IMO the easiest to use and are reasonably fast. Both Diamond and Radiant.
They also used to have pretty cheap dev boards, they have bumped up their prices a while ago though, but one can still find dev boards at reasonable prices.

Agreed. We recently purchased a couple of Icepi Zeros based on the Lattice ECP5 25F. This is a possible contender for our next Astrobe RISC5 target while waiting for a GateMate-A2 update to the Olimex board to be released.

https://github.com/cheyao/icepi-zero

[Doctorandus_P]

So you want "best", "easiest", "rich study data" and "cheap dev board".

I'm not sure you can even pick three out of those four.

For "cheap", you can have a look at the Litex colorlight boards, for example:

https://html.duckduckgo.com/html?q=5A-75B

These boards have an (dual) ethernet port on one side, and a lot of buffers with TTL chips to drive LED matrices on the other side. Because of the low cost of these boards, a lot of DIY work has been done with them. This generally includes replacing some buffers to create inputs instead of only outputs. One way these are used is as an motor control I/O board for LinuxCNC.

[Doctorandus_P]

I just found this Gatemate development board:

https://www.olimex.com/Products/FPGA/GateMate/

And it ticks a few interesting boxes for me:
* Chips are made in Europe.
* Open source toolchain, also works with Linux.

When it comes to actual availability of the chips themselves it already becomes more complicated. Putting chips on DIY boards is also a bit of an issue with BGA's, but BGA's are common among many FPGA families.

And though I'd like to do some FPGA projects, modern uC's are already more then I can handle, so the chance I'd ever do an FPGA project is very small. (I did once dip a toe into an ispLSI1016 project, but that got stalled somewhere halfway (But I did get the first half to run).

[zapta]

For "cheap", you can have a look at the Litex colorlight boards, for example:

https://html.duckduckgo.com/html?q=5A-75B

I am using another board from the same developer, it has a dimm connector that makes it easy to integrate it with your own custom boards and it's support by Apio.

https://www.tindie.com/products/johnnywu/icesugar-pro-fpga-development-board/