LeoInferenceCore / APPLICATION-DEFINED ASIC

Build your ASIC
for your application.

Let the workload define the hardware. Configure the AI core around your application rather than adapting the application to a fixed GPU or accelerator architecture.

Requirements for workload, size, memory and host go into the LeoGreenAI compiler, which generates the hardware RTL and the software in one automated flow on one ISA. Out come AI cores of different sizes, vision only, language only, or both, each with a GEMM array for LLM prefill and a GEMV engine for decode, connected through LeoMemoryInterface to any number of memories chosen at compile time.
One compiler, any core. Your requirements go in; the compiler generates the hardware RTL and the matching software in one automated flow, on one ISA. Size the core up or down, choose language, vision or both, and connect any number of memories through LeoMemoryInterface, with every interface generated at compile time. GEMM serves LLM prefill and GEMV serves decode. Physical implementation is scoped with each ASIC program.

Configure the whole core.

Choose compute dimensions, functional blocks, precision behavior, buffers, memory channels, and integration interfaces for your design.

Language, vision, and matrix workloads.

LLMs, convolutional networks, and MLP operations share the architecture. Supported families include Llama, Mistral, Qwen2 / Qwen2.5, and Phi-3, alongside supported vision networks. Model support follows the compiler’s operator coverage.

GPU-prepared models. No retraining.

GPU-compatible quantization and mixed-precision numerics let supported quantized models compile for our hardware without retraining. Outputs are validated against the reference path: bit-exact vision results and position-by-position LLM logits.

Supported GPU-prepared model→Compile + validate→Instructions + data→Your configured ASIC

ASIC 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

A configurable inference architecture
for your chip.

The core is a synthesizable hardware IP block plus its software stack. Start from the FPGA-validated RTL lineage, configure the compute and memory system, and scope integration and physical design for your program.

Inside the core

Systolic array

A grid of INT8 multiply-accumulate units, sized at build time, for transformer layers, convolutions and attention.

On-chip buffers

Partial-sum and global-buffer SRAM next to the array, so data is reused on chip instead of re-read from memory.

Floating-point island

Softmax, RMSNorm, SiLU/SwiGLU, rotary position encoding, residual adds and the core’s own run-time quantization scales.

GEMV engine

A fast path for generating text token by token, where one row of activations meets every weight.

Multi-token decode loop

Generates several tokens per program, which cuts host round trips.

KV cache in memory

Holds the attention history of a conversation, appended in place on each new token.

Vision blocks

Convolution, pooling and the INT8 vision data path, switchable at build time.

LeoMemoryInterface

Connects the core to memory through a configurable number of memory lanes, sized at compile time.

Custom ISA

The compiler emits it and the hardware runs it with no CPU in the loop. The same ISA as LeoFPGAstream.

02 / WHY LEOINFERENCECORE

Generated for your chip.
Not picked from a catalog.

Licensed AI accelerator IP usually comes as a few fixed configurations, a software kit on the vendor’s roadmap, and a model list that grows when the vendor gets to it. LeoInferenceCore is generated: the compiler builds the core to your area, power, memory and model targets, and the same compiler then runs your models on it. The core you tape out is the one we already run on FPGA boards today.

Sized to your silicon

Array size, buffers, memory lanes and features are build parameters. Leave out what your product does not need, and spend the area where it counts.

Proven before tapeout

The same ISA and core run today as LeoFPGAstream on FPGA boards. Your software team develops on real hardware long before your silicon exists.

Language and vision, one core

Transformers with grouped-query attention, RoPE and SwiGLU, plus convolution, pooling and vision models, on one array with one compiler.

ASIC and FPGA side by side

One ISA across ASIC and FPGA. Mix them in one system, or move between them, with the same programs.

LeoInferenceCore vs typical licensed AI accelerator IP

Comparison of LeoInferenceCore with typical licensed AI accelerator (NPU) IP
LeoInferenceCoreTypical licensed NPU IP
ConfigurationGenerated by the compiler to your area, power and model targets: array size, buffers, memory lanes and feature switches.A few fixed configurations from a catalog.
ModelsLLMs and vision on one core: grouped-query attention, RoPE, SwiGLU, KV cache, plus standard, depthwise, pointwise and strided convolution and pooling.Often vision-first; LLM support limited or a separate block.
AccuracyLLM logits identical to the reference, position by position; vision bit-exact. No retraining.Often vendor quantization tools or retraining, with an accuracy loss to check.
New modelsJust a compile: minutes to a couple of hours, depending on model size, on the same silicon. Off-the-shelf models from Hugging Face or GitHub.Often waits for a vendor SDK update or model zoo.
Before siliconThe same ISA and core run today on FPGA boards (LeoFPGAstream). Develop and test software on real hardware.Usually simulation or emulation only until silicon returns.
SizingThe compiler checks each model before you build: whether it fits each array size, and at what context length.Sizing from vendor estimates and benchmarks.
MemoryLeoMemoryInterface connects the core to memory through any number of lanes, sized at compile time.Usually one memory interface type.
Hybrid systemsSame ISA on ASIC and FPGA: run them side by side or split one model across both.Separate stacks for the ASIC and any FPGA.
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 host CPU or firmware; visibility varies.
SoftwareA matching compiler and runtime come with each core configuration.An SDK tied to the vendor’s release schedule.

The licensed-IP column describes the usual pattern, not any one product. ASIC implementation, physical design and qualification are scoped with each program.

03 / SUPPORTED MODELS

Your model in,
a program for your core out.

General model intake: a model goes in and the compiler emits the instruction program, with no model-specific hand-tuning. Support follows the compiler’s operator coverage, and 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. Bring unquantized safetensors or INT8 W8A8 checkpoints; quantization uses SmoothQuant, per-channel weights and calibrated activation scales, then a quality gate against the reference.

Next on the model list

3B–8B models through the full service flow (Llama-3.1-8B already runs at the largest array size) · Qwen3 (needs QK-norm) · Gemma (needs GELU) · 4-bit weights.

Plan your LeoInferenceCore configuration ↗Explore LeoFPGAstream →