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.

The LeoGreenAI compilers produce one bitstream per FPGA. A small FPGA gets an 8 by 8 AI core, a midsize FPGA a 16 by 16 core and a large FPGA a 32 by 32 core; the rest of each device stays free for other logic.
One architecture, compiled to the device. Small, midsize and large FPGAs from any vendor: the AI core grows with the fabric, the rest stays free for other logic, and every size runs the same Leo ISA. Each device gets its own bitstream.

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.

LeoGreenAI compilerInputCompiler outputThird-party implementationOperating productSelect a stage, or use the arrow keys.

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.

One model is compiled into three parts that run on three FPGAs from different vendors, linked in a chain. All three run the same Leo ISA, compiler output and runtime.
Many FPGAs, one model. The compiler splits a model across several FPGAs, even from different vendors and of different sizes. Every device runs the same Leo ISA, so the program format and runtime stay the same.

LeoFPGAstream vs a vendor-specific FPGA AI flow

Comparison of LeoFPGAstream with a typical vendor-specific FPGA AI inference flow
LeoFPGAstreamTypical vendor-specific flow
FPGA choiceAny vendor, any size. The compiler generates a bitstream for each device.One vendor’s devices and toolchain.
Older and unsupported FPGAsRuns 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 chainChange 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 ASICSame 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 modelSeveral FPGAs, even from different vendors, share one model over the common Leo ISA.Multi-device setups stay within one vendor’s parts.
WorkloadsLLMs 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 modelJust 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.
AccuracyLLM 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 bandwidthUses every memory on the board, HBM, DDR, LPDDR and on-chip, as parallel lanes, through LeoMemoryInterface.Typically one memory interface per design.
ConfigurabilityArray 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 controlNo 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.

Plan your LeoFPGAstream configuration ↗Explore the next family →