heliaAOT

Bring blazing-fast, ultra-compact neural inference to Ambiq’s ultra-low-power SoCs—without a runtime.

heliaAOT is an ahead-of-time (AOT) compiler that converts front-end models (e.g., TFLite) into stand-alone C inference modules optimized for Ambiq microcontrollers. By shifting codegen to build-time and eliminating the runtime interpreter, heliaAOT delivers compact, readable C with zero arena-guesswork and no dead code.

✨ Why heliaAOT?

• Smaller binaries – Generate only the code you need. No interpreter, no dead kernels.
• Deterministic memory – Context-level memory planning; stop guessing arena sizes.
• Readable output – Layer-mirrored C files for fast bring-up and debugging.
• Ambiq-tuned – Optimized for Cortex-M (M4/M55/Helium) on Ambiq SoCs.
• Fits your build – Emits a CMake, Zephyr or NSX module, or sources for your existing build system.

🚀 Quick Start

Option A: Install via pipx

pipx install --python python3.12 helia-aot
helia-aot --help

We recommend pipx because it installs Python apps in isolated, self-contained environments and puts the CLI on your PATH.

Option B: Install via uv

uv tool install --python python3.12 helia-aot
helia-aot --help

In options A and B, --python picks the interpreter for the tool's environment. heliaAOT supports Python 3.11 to 3.14, so any of those works.

Option C: Install via pip

python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
python -m pip install helia-aot
helia-aot --help

🧭 First Conversion

helia-aot convert \
  --model.path ./model.tflite \
  --module.path ./out \
  --module.name my_model_aot

What you get:

out/my_model_aot/
├── CMakeLists.txt        # CMake library target; other --module.type values emit their own build files
├── LICENSE               # License for the generated module
├── README.md             # Module usage notes and requirements
├── aot_plan.json         # Optimization plan: the choice made for each operator
├── aot_report.json       # Why each choice was made, with sizes and hints
├── includes-api/         # Public C headers
└── src/                  # Model, tensors and operator implementations

Drop the folder into your firmware tree and build like any other C module. --module.type selects the build files: cmake (the default), zephyr or nsx. The module calls heliaCORE, Ambiq's kernel library, and needs the ns-cmsis-nn release its README names. CMake output leaves the AOT_PRINTF logging hook and the AOT_PUT_* memory placement hooks as no-ops unless your application supplies them (the AOT part follows --module.prefix); see Firmware integration.

🛠️ Current CLI

heliaAOT exposes the following commands:

• convert – Convert a TFLite model into a C inference module.

  helia-aot convert --help
  

• platforms list – List every supported target platform name.

  helia-aot platforms list
  

• platforms show – Show a target's CPU, clock speeds, memories, and capabilities.

  helia-aot platforms show apollo330mp_evb
  

  list-targets and target-info --name NAME are deprecated aliases, removed in 2.0.

• version – Print the installed heliaAOT version.

  helia-aot version
  

  We follow “progressive disclosure of complexity.” The CLI starts simple; advanced flags and expert workflows are documented in the site’s Guides and Reference sections.

📚 Documentation

• Getting Started: the fastest way from model → C module
• Guides: configuration, memory, precision, testing and troubleshooting
• Reference: every command, setting, target, operator and error
• Compatibility and versioning: what a release promises and what it does not
• Benchmarks: dated size and speed comparisons, with their conditions
• API: for power users who integrate deeper

The docs are written for CLI users first; you don’t need to know (or care) that the tool is implemented in Python.

🔌 Supported Inputs & Targets

Inputs

• LiteRT/TFLite flatbuffers with int8 or int16 quantization
• float16 and float32 operators

Targets

• Ambiq SoCs (Cortex-M4, M55/Helium); helia-aot platforms list names them
• Integration paths: CMake, Zephyr and NSX modules; CMSIS-Pack (evaluation)

🧩 What the Generated C Looks Like

• A compact operator library: only kernels required by your model.
• A structured init() / run() style API with clear I/O.
• Compile-time tensor shapes and a fixed memory plan.
• Optional operator callbacks for instrumentation/telemetry, with the default module.schedule: table.

🧪 Testing & Quality

• Continuous Integration runs linting and unit tests
• Deterministic builds and reproducible outputs where possible
• Example apps and benchmarks in the docs

💬 Support & Feedback

• Support, licence and contributing: what to include in a report
• Email: support.aitg@ambiq.com

📄 License

heliaAOT generates C modules whose license restricts their use to Ambiq hardware. See the generated module’s LICENSE for its terms, and Support, licence and contributing for the tooling’s licence.

Ready to dive in? Head over to the Getting Started guide and generate your first module in minutes.