LeoFPGAstream / FPGA INFERENCE
Bring the FPGA.
Enable AI inference.
Turn FPGA resources into a complete, general-purpose AI accelerator. Generate a bitstream for the device and resource budget, then run compiler-supported language and vision models on the configured core.
Different sizes. One architecture.
Configure core dimensions and features for the available FPGA fabric, leaving resources for other logic.
A common software contract.
The shared ISA and matching compiler/runtime conventions give different FPGA configurations a consistent programming model.
Designed for mixed systems.
Use the shared architecture across different FPGA targets. Host I/O, links, and system coordination are integrated for each deployment.
FPGA INFERENCE FAMILY
Compile and Design Flow
Explore how your requirements become operating hardware. Select any stage in the flow.
01 / WHAT IT DOES
Load the bitstream.
Bring your models.
The bitstream puts a complete, general-purpose AI core on your FPGA, not a datapath built for one model. Once loaded, it runs every model the compiler supports.
What we put on the FPGA
A general-purpose core
A complete accelerator: systolic array, on-chip buffers, a floating-point island, a GEMV engine and a custom ISA. No CPU in the loop.
Language and vision on one core
Transformers and language models, plus common convolution types: standard, depthwise, pointwise, strided, and pooling.
Configurable
Choose the array size, memory and features. Language or vision support can be turned off at build time to save area.
Out-of-order execution
A hardware scheduler keeps the compute array busy across mixed workloads.
Mixed precision
INT8 matrix math with floating-point non-matrix math, so results match the reference path.
Why that matters
No retraining
Results match the GPU reference path, so a supported model works as published.
No model zoo needed
Run off-the-shelf quantized models from GitHub or Hugging Face through the supported compiler path.
Minutes to a new model
A compile of minutes to a couple of hours, depending on the model’s size and complexity. Not retraining, export or hand-mapping.
One ISA for FPGA and ASIC
The same instruction set as LeoInferenceCore makes hybrid ASIC + FPGA systems straightforward.
02 / WHY LEOFPGASTREAM
Not tied to one vendor.
Not tied to one chip.
Vendor AI tools are built to sell that vendor’s FPGAs. They follow its device list, its toolchain and its roadmap. LeoFPGAstream is built the other way around. The AI core is defined by an ISA and a compiler, and the FPGA is simply where it runs today. Your models and software stay the same when the device, the vendor or even the silicon changes.
Supply chain on your terms
Compile for whatever FPGA you can source, new or old, large or small, from any vendor. A shortage or an end-of-life notice becomes a recompile, not a redesign.
A path to silicon built in
LeoFPGAstream and LeoInferenceCore share one ISA and one compiler. Prototype and ship on FPGA, then move to an ASIC, or run both side by side, with the same programs.
Scale out across vendors
Split one model across several FPGAs, even from different vendors and of different sizes. Every device speaks the same Leo ISA.
Every memory, in parallel
LeoMemoryInterface turns each memory on the board into lanes and reads them together. On the board, one model spread over five memory ports ran 1.85× faster per token than on one port.
LeoFPGAstream vs a vendor-specific FPGA AI flow
| LeoFPGAstream | Typical vendor-specific flow | |
|---|---|---|
| FPGA choice | Any vendor, any size. The compiler generates a bitstream for each device. | One vendor’s devices and toolchain. |
| Older and unsupported FPGAs | Runs on older and low-cost parts, including devices that vendor AI tools no longer cover. Board-proven on a low-cost FPGA family more than a decade old. | Usually only current device families. |
| Supply chain | Change device or vendor without changing models, software or the host interface. | A new vendor means a new AI stack and a new port. |
| Path to ASIC | Same ISA and compiler as LeoInferenceCore. Swap the FPGA for an ASIC, or mix both, and the software does not change. | FPGA only. An ASIC is a new design and a new software stack. |
| Many FPGAs, one model | Several FPGAs, even from different vendors, share one model over the common Leo ISA. | Multi-device setups stay within one vendor’s parts. |
| Workloads | LLMs and vision on one core: transformers with grouped-query attention and RoPE, plus standard, depthwise, pointwise and strided convolution and pooling. | Often vision-focused, or separate IP per workload. |
| New model | Just a compile: minutes to a couple of hours, depending on model size. The bitstream does not change. | Often a rebuild, re-synthesis or a vendor model zoo. |
| Accuracy | LLM logits identical to the reference, position by position; vision bit-exact. No retraining. | Often retraining or vendor quantization tools, with an accuracy loss to check. |
| Memory bandwidth | Uses every memory on the board, HBM, DDR, LPDDR and on-chip, as parallel lanes, through LeoMemoryInterface. | Typically one memory interface per design. |
| Configurability | Array size, clocks, memory mix and features are build switches. Unused blocks are left out, and the rest of the fabric stays yours. | Fixed IP configurations. |
| Host and control | No CPU in the loop: the host streams the program and the core runs it. Hardware counters show stalls, utilization and timing. | Often needs a soft or hard CPU; visibility varies. |
The vendor-specific column describes the usual pattern, not any one product. Device support for LeoFPGAstream is a compile and qualification step for each new target.
03 / SUPPORTED MODELS
Your model in,
a program for your FPGA out.
A model goes in and the compiler emits the instruction program, with no model-specific hand-tuning. Every supported model is graded against its reference.
Language models
Llama 3 / 3.1 · Mistral · Qwen2 / Qwen2.5 · Phi-3 · SmolLM2 · …
Transformer language models with multi-head or grouped-query attention, RoPE and SwiGLU MLPs.
Vision models
ResNet-18 · ResNet-56 · VGG16-BN · MobileNetV2 · YOLOX-tiny · YuNet · SRCNN · …
Classification, detection, face detection and super-resolution on the same core.
A new model is a compile
Bringing a new model only requires compiling it. The compiler checks, quantizes, validates and builds the program in minutes to a couple of hours, depending on the model’s size and complexity. No retraining, no new bitstream or silicon, no hand-mapping.
Identical, not just close
Language-model logits are compared position by position with the reference; vision outputs are bit-exact. No release ships without these checks, a full board test and a rollback path.