Skip to content
heliaRT
Home
HELIA HUB

heliaRT

Proven LiteRT workflows.
Turbocharged on Ambiq silicon.

heliaRT is Ambiq's optimized LiteRT runtime: the same .tflite models and MicroInterpreter API, backed by heliaCORE kernels tuned for Ambiq silicon.
Get startedWhy heliaRT
v1.21.2
LiteRT APIMicroInterpreter + OpResolverheliaCORE kernelsSelected at build timeTensor arenaApplication-owned memoryOperator profilingPer-operator timing
InferenceC++
tflite::MicroMutableOpResolver<3> resolver;
resolver.AddConv2D();
resolver.AddFullyConnected();
resolver.AddSoftmax();

tflite::MicroInterpreter interpreter(
    model, resolver, arena, kArenaSize);
interpreter.AllocateTensors();
interpreter.Invoke();

Keep your LiteRT surface. Swap the backend underneath.

Your model and application stay at the center. heliaRT manages graph execution, while the selected backend supplies the operator implementations.

  1. 01 · Model.tflite

    Your trained model

    A FlatBuffer graph with tensors, constants and operator requirements.

    Check model compatibility
  2. 02 · RuntimeheliaRT

    The familiar interpreter

    Register operators, allocate tensors, supply inputs and invoke the graph.

    MicroInterpreterApplication-owned model, resolver and arena
  3. 03 · BackendheliaCORE

    Ambiq-tuned kernels

    HELIA adapters dispatch supported operations to heliaCORE.

    Select your backend
Selected at build timeHELIA, CMSIS-NN and Reference are backend choices. Fallback behavior depends on the individual adapter and tensor configuration.
Operator coverage

Look beyond the convolution.

HELIA adapters also connect activation, arithmetic, reduction and data-movement operations to heliaCORE. Check the tensor types and shapes your model uses, not just the operator names.

Explore model compatibility

FP32 and FP16 paths have their own build requirements and support limits. Kernel availability alone does not establish model compatibility.

  • Compute

    Convolution · Fully connected · Pooling

  • Activation & math

    Softmax · Tanh · Sqrt / Rsqrt

  • Arithmetic & reduction

    Add / Sub / Mul · Mean · Arg min / max

  • Data movement

    Gather · Split · Pack / Unpack · Fill

Start with the tools you use.

CMake, Zephyr, neuralSPOT-X source builds and CMSIS-Pack share one source manifest and backend-selection rules. Choose the integration that fits your application.

RTOS integration

Zephyr

Add the module to your west workspace and configure the backend through Kconfig.

Ambiq development

neuralSPOT-X

Integrate the runtime with your neuralSPOT-X application’s build.

Arm ecosystem

CMSIS-Pack

Package runtime sources for a CMSIS-based project.

Custom firmware

Source and CMake

Build the runtime or link a compatible release archive into your own application.
Build choices

Choose what your firmware needs.

Use a matching release archive for a fixed configuration, or build from source to select the backend, floating-point features and kernel profiles.

Configure your build →
Source or prebuilt
Own the build configuration, or link an archive whose settings match your application.
SPEED or SIZE
Select the HELIA kernel profile in source builds, with per-family overrides where available.
GCC · Arm Compiler 6 · ATfE
Match the library and application toolchain. Compiler choice and kernel profile are separate decisions.

Choose the inference path that fits.

For supported models, heliaAOT is the recommended option when targeting latency, power and memory efficiency. Use heliaRT when your application calls for the LiteRT interpreter and its runtime integration.

Ahead-of-time compilation

heliaAOT

Compile a supported model into standalone inference code. Check model compatibility in the heliaAOT documentation.

LiteRT runtime integration

heliaRT

Load a model, register its operators and manage the tensor arena through the familiar MicroInterpreter API.

Take the next step.

Bring an existing application across, run a checked first inference, or understand a model’s requirements before integrating it.

First inference

Follow model validation, operator registration, tensor allocation and invocation in order.

Migrate from LiteRT

Keep a known model baseline and verify the runtime, build and output contracts together.

Check compatibility

Understand tensor types, floating-point features and allocation versus invocation failures.