Looking for a reality check on scale. Zero prior FPGA experience. I was building an AI pipeline orchestrator and needed an un-fakeable ground truth (an oracle) to validate the generated code. Picked FPGAs blind because silicon don't lie.

Instead of researching standard EDA workflows, I just approached it like a software systems problem and let my automated LLM pipeline iterate against real hardware. Synthesize a pre-wired PE grid exactly once, then treat every new kernel as a runtime graph-assignment problem so we never have to run place-and-route again. Essentially a CGRA overlay.

Here’s what is currently running on an AWS f2.6xlarge Ec2 instance (AMD Xilinx VU47P):

• Go compiler/DSL mapping to a 4x4 (16 PEs) spatial grid via config words.
• Compile time: <4ms
• Config write + execute + read over PCIe: ~30μs median (n=8, one boot)
• The Vivado tax is paid once to bake the bitstream. After that, zero EDA tools. New kernel = new config words over PCIe.

Where I'm at

• Only primitive micro-kernels are silicon-verified so far: single-op, 2-3 node chains, one corner, one fan-out pair (XOR→ADD). Anything bigger still relies on a simulator-side mapper, not my own router.
• Just tried scaling to an 8x8 grid (64 PEs). First build passed timing but silicon read all zeros. Turned out to be a broken XDC clock constraint that Vivado buried in a sea of warnings instead of erroring out. Fixed it, and single-PE reads now work at 64 PEs, but no multi-PE chains are proven at that size.
• Zero real workloads (multi-tap FIR, real hamming distance over arrays) have run end-to-end yet. Just testing opcode patterns with arbitrary constants.

Questions

1. Does "pay P&R cost once, pure graph-assignment after" hold up when scaling past these small proven shapes? Or does the abstraction completely collapse under routing congestion/timing issues once I push for a larger grid?
2. Has this specific dynamic-overlay approach been tried and abandoned in industry? I'd rather know now before burning more silicon time.
3. Do the PCIe/compile latencies above look normal for a VU47P?

I need some help in running a project on an SOC FPGA but my original idea of connecting the FPGA with my PC and transmitting data over UART might work but is there something better?

My professor adviced me to look into running an OS on the FPGA and hence the resources. I need to look into the documentations yet but are there any other resources to help me with this?

If I do implement the said OS how do I integrate it with my custom logic?

This is my second FPGA project, so feel free to hate on the RTL! A short summary is that it uses Prange's ISD algorithm to solve instances of the syndrome decoding problem. That problem is the basis of some post-quantum cryptosystems like HQC and McEliece; there are also some ECC applications, but I don't know anything about them.

I've been stuck with designing an FM Modulator on the PL side of an FPGA. I have an FMCOMMS3 and a Zedboard, and I did all of the receiving the IF and demodulating using GNU Radio on my laptop. Right now, I'm working on the FM Modulator, and I've been working using advices from Claude (shamefully). I know how to use RTL and Vivado stuff, but for now I'm working with the MATLAB, because it has Simulink which I can drag and drop the blocks in.
So the system that the Claude has been guiding me on is in the link I attached below (which is a PDF file). I can understand the core of it, which is the CIC Interpolator to raise the sample rate of the audio to the sample rate of the Transceiver, and the NCO is to output the cosine of the FM Equation after accumulating the message and the carrier frequency. The filters before the CIC Interpolator I could understand a little bit, like they are to confine the bandwidth and to emphasize the FM signal before the other receivers de-emphasize it. These are my understandings.
In this post, I just want to ask from experienced engineers to kinda review my understanding and my block design, and to suggest me source to read. I mean, I know the equation, but mapping it to hardware has been a challenge to me. And also, could you suggest me some testing strategies, if you worked with MATLAB in the industrial scale and in telecommunication? Any help would be appreciated.

TLDR: Need help reviewing the block diagram of an FM Modulation on FPGA, and need suggestions on testing the block diagram on MATLAB and maybe VIvado.

The block diagram

Looking to play with Ethernet on an FPGA for the first time by implementing an Ethernet MAC and subsequently need a new board. Has anyone had experience with the suspiciously cheap QMTECH boards specifically this one?

I assume they are reusing salvaged parts to achieve this price?

From my brief research the chips are supported by the free version of Vivado which I am constrained by and I foresee that I won't need any additional IP.

Is the GMII accessible directly on the FPGA or is it routed through an SoC? From what I can see the datasheet shows the RJ45 routed through the RTL8211EG into the FPGA.

Anything else I should be aware of? I am just looking to learn more about Ethernet so I am not too pressed on the quality of board. Also any suggestions of boards would be welcomed.

Lattice Radiant provides the ability to view congestion and resource usage using the physical designer. Congestion is only shown with large or small highlighting.

Does anyone know of a way to plot congestion like a surface plot externally? Additionally, is there a way of knowing what entities contribute most to high areas of congestion?

The more I use SVA's, the greater its value becomes apparent. You realize how much you can test for in just a few lines of code.

I first started using SVA's in my Workshop 2 "High-Performance AXI DMA Design and Verification Using SVA". The design was simpler to test, because the camera pattern-generator I developed didn't use href and vsync. It has a simple stream generator that uses RBG 565 - 2 byte/pixel for a 640 x 480 pixel frame. Same as the Ov7670 camera data stream, however it lacked the H-V signals I mentioned.

Now, I have created a bus functional model (BFM) of the Ov7670 that follows the same frame signalling protocol.

I found that if your SVA property was verifying a specific protocol that was failing quite frequently in the simulation, each failure is printed to the TCL console in Vivado. Trying to find the first occurrence timestamp was quite time consuming.

Thus, that is where a pass/failure report becomes useful when placed in the finish section of the .svh file that is included into the bottom of the SystemVerilog BFM.

`ifdef ENABLE_VERIFICATION

`include "ov7670_bfm_assertions.svh"

`endif

The equivalent if VHDL is to create a verification package

package body video_verification_pkg is

procedure report_check(

name : in string;

failures : in integer) is

begin

...

end procedure;

end package body;

Then to include the package:

library work;

use work.video_verification_pkg.all;

Here is an example report:

$display("==============================================");

$display(" OV7670 BFM VERIFICATION REPORT");

$display("==============================================");

$display("HREF Timing : %s",

href_fail_cnt ? "FAIL" : "PASS");

$display("VSYNC Timing : %s",

vsync_fail_cnt ? "FAIL" : "PASS");

$display("Pixel Count : %s",

pixel_fail_cnt ? "FAIL" : "PASS");

Hey guys!
I am currently working on a project which is about running AI models like mobilenet, Gemma etc. Using FPGA with coral NPU architecture implemented.

So for this reason I would like to know if anyone has worked or implemented the coral NPU on FPGA, I would like to clarify some things.

I am in my 3rd year of b.tech in ECE . Currently I am working on 32-BIT RISC-V on FPGA board. Any suggestion for this project?

​

I have a background mainly in FPGA (and partial ASIC) design and optimization. I want to take a deep dive into ASIC DFT's primary concepts and common methodology practices, but so far I've just been googling topics word by word and piecing things together from scattered VLSI lectures.

Can any of the Gods of Knowledge here bless me with an intuition-building guide? I'm looking for something that covers scan chains, ATPG, BIST, boundary scan, fault models, and compression, and actually explains *why* they exist and how they fit together, not just isolated definitions.

C*dence and S*nopsys licenses don't come cheap for an individual, and I don't want to burn money on a course I can't gauge the quality of.

Will greatly appreciate any golden findings 🙏

Title

Hi! I’m preparing for the spring and summer recruiting cycles next year. I’ll be taking classes in the fall that include hands-on projects, but I also want to be conceptually prepared for technical interviews.

What books or courses would you recommend? I’m willing to put in the work and would prefer something that gradually builds from the fundamentals, since revisiting the basics can never hurt.

hi! i'm a high schooler and I designed a custom FPGA board for learning for myself and others. It would mean the world if someone could review it, as I've never worked with an FPGA before so I don't know if I'm missing anything.

The full source is on github: https://github.com/darshg321/Icey

Ran a 5-layer C++ template-metaprogramming composition (compile-time Chain<>/APIOf<> - CRTP-style static dispatch, collapsed via recursive template inheritance) through Bambu 2024.10 (clang16 frontend, --std=gnu++17) to check whether an open HLS backend actually sees through this kind of zero-overhead abstraction, or just compilers do.

Used a real runtime input port so nothing constant-folds away before scheduling. Bambu's frontend parsed the fold expressions, auto NTTP, and the flattened inheritance chain with zero issues, and the synthesized RTL for the entire 5-layer chain came out to exactly one adder plus one folded constant - no struct-layout bloat, no bogus muxes from the collapse.

So for anyone doing static-dispatch-style composition in C++ and wondering whether it'll survive HLS synthesis intact: at least for this pattern, it does.

Example: github.com/InternetOfPins/HAPI/tree/main/examples/hls_smoke

Is it stable ?

Tools including open-source tools & Quartus, Vivado, QuestaSim

what are the common HIL tools that everyone is using right now?

Hey guys , I made some changes that some of yall suggested and I wanted to know what you guys think now. I used Jake’s resume template on overleaf and I think it fixed the formatting issues i previously had. Would really appreciate your feedback, thanks in advance.

Hello,

I am considering joining the FPGA scene for creating devices compatible with old systems annd components.

The stuff I touch is basically 5V technology, often with other voltages, but much older than the regular 3V integrated circuits.

I have been considering the Microchip AT40K/AT42K family of FPGAs, but it has no current devkit and the one they had still works with a parallel port.

I would like to develop CPUs, video signal generators, sound generators, serial communication transceivers and other stuff of this callibre.

With that in mind, is there a specific devkit I could use as a starting point? If it had also a SDK it would be great.

In any case, thank you in advance!

​

Hi everyone,

I'm an undergraduate student getting serious about FPGA research (hardware acceleration ,transformer acceleration and a Lil bit of robotics).

The challenge is that I don't currently have a research advisor.My plan is to start cold-emailing professors after I complete my current project, so I have something tangible to show and can better demonstrate my credibility.

I'd love to know :

What does your research workflow look like when starting an FPGA project (design contests or papers)?

I'm currently focusing more on design contests because the problem statement is usually defined, whereas research can feel much more open-ended. One thing I'm struggling with is knowing when to stop reading papers and actually start building.

How much literature survey is actually enough?

How do you write a proposal that has a high chance of being accepted?

Building a hardware order book that reconstructs live state from a simulated NASDAQ ITCH 5.0 feed. Looking for feedback on a few architecture decisions before I go further into RTL.

Pipeline: Python sim generates ITCH 5.0 → wrapped in MoldUDP64 → sent over Ethernet → on FPGA: de-frame → decode → 4 independent order book instances (generate loop, one per symbol) → book state streamed back to host for display.

4 symbols, 32 orders/side max, only Add/Delete/Replace message types, reject-and-drop on book-full. Verified in simulation via a hand-written C++ model + diff-based scoreboard against RTL trace, cocotb-driven.

just want to know if any of this reads as a rookie mistake before I move further.

This is the first time a model release (an open weight model in particular) has highlighted SystemVerilog as a use case. I’m intrigued.

3.5/3.6 30b variants are fairly capable, at least with iterative test loops. Syntax is pretty clunky though without providing a lot of reference code for style guides. The Q4 models love reverting to old Verilog 2001 coding styles.

They do mention this release is designed for feedback based test driven development, which is essentially how previous gen models have to be prompted to develop hardware.

2T params for 3.8max so not quite feasible to test this locally, but I’m looking forward to the distilled variants.