Shrike: a low-cost FPGA board family with a microcontroller host

Three members of one family

Shrike is a family of low cost affordable FPGA development boards along with a host microcontroller, and the family currently features three members.

Shrike-lite is the FPGA with an RP2040, Shrike is the FPGA with an RP2350, and Shrike-fi is the FPGA with an ESP32-S3. The documentation also says that a lot of versions are under development.

The structure is the same in all three: an FPGA, a microcontroller, and an interface between them. The microcontroller is the host that runs your firmware, using CircuitPython, MicroPython or embedded C as the topic list suggests, and the FPGA is the reconfigurable fabric you program for the logic the microcontroller does not have.

That pairing is what the project calls heterogeneous computing, and it is the reason the board exists in this shape. An FPGA alone is awkward to use, because everything has to be written in a hardware description language and the debugging story is poor. A microcontroller alone cannot do the parallel bit-level work an FPGA is good at. Putting them together with a documented interface between them is a design that lets a learner start with the microcontroller and move work into the fabric as they learn.

The origins are stated plainly. The team at Vicharak usually work on very complex FPGA-based projects built around Vaaman and its upcoming series, and Shrike is a passion project, driven by their love for engineering across both embedded microcontrollers and FPGAs. The goal is to make FPGAs accessible to everyone by offering dependable toolchains, good hardware and strong ecosystem support, and the project is committed to keeping the hardware prices extremely low and to making every piece of software for Shrike completely open source.

The licence split is worth noting early, because it is unusual. The software is GPL-2.0, and the hardware designs, covering the HDL and RTL, the schematics, the PCB files and the constraints, are licensed under the CERN Open Hardware License v1.2, with the details in separate files.

The board, feature by feature

The key features table is the most useful page in the documentation, because it puts the three variants side by side and shows how little actually differs.

| FPGA                                | 1120 × 5-input LUTs     | 1120 × 5-input LUTs    | 1120 × 5-input LUTs|
| MCU                                 | RP2350                  | RP2040                 | ESP32-S3           |
| PMOD Compatible Connector           | ✅                      | ✅                     | ✅                 |
| Breadboard Compatible               | ✅                      | ✅                     | ✅                 |
| FPGA ↔ MCU IO Interface             | ✅                      | ✅                     | ✅                 |
| Flash (QSPI)                        | 4 MB                    | 4 MB                   | 8 MB               |
| User LEDs                           | 2                       | 2                      | 2                  |
| USB Type-C (Power & Programming)    | ✅                      | ✅                     | ✅                 |
| WiFi                                | ❌                      | ❌                     | ✅                 |
| BLE                                 | ❌                      | ❌                     | ✅                 |

The FPGA is the same part in all three, 1120 five-input LUTs, which is a small device and an honest one. That size is enough for the examples the project ships, including a RISC-V CPU, and it is small enough that the price can be very low.

Everything about the physical interface is identical across the family: a PMOD compatible connector for the standard expansion modules, breadboard compatibility, and the FPGA to MCU IO interface, which is the part that makes the board interesting. The board block diagram is published as an asset, and there is a separate page for the FPGA to MCU communication pin outs, which tells you the interface is treated as a first-class documented thing rather than an afterthought.

Two LEDs, a USB Type-C for both power and programming, and QSPI flash of 4 MB on the two RP boards and 8 MB on the ESP32-S3 variant. The wireless options are the only real functional split: the Shrike-fi has WiFi and BLE and the other two have neither.

There are also two optional add-on features, listed as PSRAM in QSPI and a battery management system, and both are optional on the first two boards, with the Shrike-fi offering up to 8 MB of PSRAM and a battery management system on board. The documentation is careful to say that these add-ons are not soldered in the base version of the Shrike-fi, that a board version with the parts soldered will be launched later, and that you can solder them yourself in the base version.

Getting the board, and the documentation that comes with it

The hardware is sold through two channels, and the split is about availability rather than about preference.

Shrike-lite, the RP2040 version of the family, is available at the Vicharak store for worldwide shipping. The Shrike RP2350 version will be available on CrowdSupply soon, and there is a Crowdsupply link for it. The Shrike-fi has its own store link as well.

The distinction between the two channels is worth a sentence, because it affects what happens when a board is out of stock. A shop run by the manufacturer can hold inventory and ship worldwide, while a crowdfunding platform listing implies the next batch is funded by orders placed in advance, which is a different commitment from a shelf.

The documentation has three entry points, and they map onto the three things you need to do with a board. There is the main documentation, there is the pin outs page, and there is the FPGA to MCU interconnect page, which is the one that matters for anyone writing code that spans the two halves of the board.

The project describes the design intent in one line: the board is the stepping stone into the field of FPGA, reconfigurable and heterogeneous computing, and it was designed with the needs of a learner, a maker and a hobbyist in mind.

For the ecosystem, there is a separate projects repository where people show what they have built, and the documentation asks contributors to add their own build there. There is a note about where a contribution belongs: the examples/ folder in this repository is focused on teaching, one concept per example, while the projects repository is for showing what people have built, and there is a classification criteria document, EXAMPLE_OR_PROJECT.md, that explains the distinction.

The community channels are listed as well, with a Discord server, a discussion forum at discuss.vicharak.in, a presence on X, a LinkedIn page and a subreddit, and the closing note is a request for contributions to the ecosystem they are building for learners, makers and hobbyists.

The examples, and what teaching one concept at a time buys you

The examples directory is the part of the repository that most directly serves the audience the board is aimed at, and its organising principle is stated clearly: the examples/ folder is focused on teaching, one concept per example.

Looking at the names, the list covers a wide and carefully chosen set of ideas. There is the led_blink, the button_debouncer, the counter_4bit, the logic_gates, the morse_blink and the led_reaction_timer for the fundamentals of driving hardware. There is the cordic, the pll_oscillator, the pwm_4ch and the quadrature_decoder for the parts of digital design that are awkward in a microcontroller. There is the i2c_led, the spi_loopback_led, the spi_to_usb and the dspi_pio_echo for the buses. There is the gpio_extender_8pin and gpio_extender_14pin for expanding the IO, and the protocol_translator for bridging two different sides.

And then there are the three that make the board more than a peripheral: shrike_picorv32, which puts a RISC-V CPU on the FPGA, shrike_picorv32_xip, which is the same CPU running with the XIP interface, and shrike_serv, which is a small SoC. Those examples are the reason the FPGA and the microcontroller are on the same board, because they demonstrate a processor that lives in the fabric and talks to the host over the documented interface.

The one-concept-per-example rule is what makes the set usable as a course rather than as a pile of code. Each example is a small program that demonstrates one thing, so a learner can read one file, build it, and see the effect, without having to understand the rest of the board to start.

The project also runs a bounty scheme from time to time, with the details in bounty.md, and the contribution guidance is explicit: fork the project, test your changes and create a pull request, and read the contribution guide for the details of what to keep in mind. The examples that are wanted are ones you have designed on Shrike, and any utilities you have written.

Where Shrike is the wrong tool

The first limit is the size of the FPGA, and it should be checked before you design anything around it. 1120 five-input LUTs is a small device, appropriate for the teaching examples and for a soft CPU, and it is not a device for image processing, for a large accelerator or for anything that needs a big fabric. The price point and the capability are the same decision.

The second is that this is a board, not a toolchain, and the toolchain is a separate problem. The project promises dependable toolchains and open source software, and the repository carries hardware, lib and utils directories, an archive directory and a test directory, and a .gitmodules file, which means parts of the design are pulled in as submodules. Somebody building a serious design with this board will spend real time on the flow from source to bitstream, and that flow is not documented in the readme.

The third is the wireless story. Only the Shrike-fi has WiFi and BLE, so a connected project means the ESP32-S3 variant, and the other two are wired or serial only. For a connected device that is the board to buy, and it also means the two wireless-less boards are cheaper in every way except the radio.

The fourth is availability and support. The RP2350 board is described as coming to CrowdSupply soon rather than being available, so the availability of the most capable of the three boards is not settled, and the two optional add-on features are not fitted to the base Shrike-fi and have to be soldered by hand, which is a real ask for a first-time board owner.

And the fifth is the open hardware licence, which is a feature and a constraint. The CERN Open Hardware License is a strong copyleft licence for hardware, and it means a derivative board has to be released under compatible terms, which is exactly the point of the licence and exactly the thing a commercial derivative cannot do. A team that needs to keep a derivative private has to change the licence or seek permission.

Editorial conclusion

Shrike is worth buying if you want to learn how an FPGA and a microcontroller talk to each other, because the board is deliberately built around that interface, with a PMOD connector, a breadboard area and an FPGA to MCU IO path, and because the examples are one concept each, so the cordic, the quadrature decoder, the picorv32 CPU and the SPI loopback are each a self-contained lesson. It is the wrong tool if you want a high performance board or a mature vendor toolchain. Before you buy, check three things: which member of the family fits, because the FPGA is the same 1120 five-input LUT part across all three while the host microcontroller, the flash size and the wireless options differ, and only the Shrike-fi has WiFi and BLE; that you are comfortable with an open toolchain rather than a vendor one, since the project states that every piece of software for Shrike will be completely open source and the FPGA side is Verilog; and that you read the hardware licence, because the software is GPL-2.0 while the hardware designs, including the HDL, schematics, PCB files and constraints, are under the CERN Open Hardware License v1.2, and a commercial derivative has to respect that.

Frequently asked questions

Official sources

1. License: GPL-2.0
2. Project website
3. README
4. Releases
5. vicharak-in/shrike on GitHub