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.
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.
ASIC INFERENCE FAMILY
Compile and Design Flow
Explore how your requirements become operating hardware. Select any stage in the flow.
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
| LeoInferenceCore | Typical licensed NPU IP | |
|---|---|---|
| Configuration | Generated 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. |
| Models | LLMs 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. |
| Accuracy | LLM 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 models | Just 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 silicon | The 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. |
| Sizing | The compiler checks each model before you build: whether it fits each array size, and at what context length. | Sizing from vendor estimates and benchmarks. |
| Memory | LeoMemoryInterface connects the core to memory through any number of lanes, sized at compile time. | Usually one memory interface type. |
| Hybrid systems | Same 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 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 host CPU or firmware; visibility varies. |
| Software | A 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.