Skip to content
neuralSPOT-X
Home
HELIA HUB

NSX

Build AI applications.
Compose your firmware.

neuralSPOT-X (NSX) is Ambiq’s modular AI SDK. Compose inference, audio, connectivity and system modules into your application. Build for Ambiq silicon with GCC, ATfE or ACFE, using bare metal or FreeRTOS, through one workflow from setup to firmware.
Get startedExplore modulesv0.9.0

THE SDK FOUNDATION

Your AI application
NSX modules
AmbiqSuite
HALBSPDevice

Your application, assembled.

Compose modules on a shared hardware foundation.

The AI SDK

Compose the capabilities your application needs.

Reusable modules connect inference, data capture, connectivity and the system services around them.

NSX resolves the modules you select and their required dependencies, then integrates them into your CMake project. HAL, BSP and device support provide the hardware foundation. Start with a bare-metal application, or add the FreeRTOS module when you need tasks.

Compose with modules

Find reusable capabilities, add them to your app and lock the resolved dependency set.

Choose your toolchain

Use GCC, Arm Toolchain for Embedded (ATfE) or Arm Compiler for Embedded (ACFE). Check the target declarations and validation status in the toolchain guide.

Bare metal or FreeRTOS

Keep a simple application loop or build on FreeRTOS tasks. The example shows the module and initialization steps.

Start here

From setup to running firmware.

Select a step to explore it. Click the active step to pause or resume.

Install the NSX CLI after setting up the host tools and compiler.

nsx doctor names every host tool it needs and what a missing one would cost you.

A complete app directory for a real board: nsx.yml, CMakeLists.txt, sources and the starter modules.

Modules resolve and lock, CMake generates, Ninja builds. The result is an ordinary project you own.

nsx flash builds if needed, then programs the board over SWD through the SEGGER tools nsx doctor checked.

nsx view opens the SWO viewer and streams the firmware's output back to your terminal.

Install the CLI
$ uv tool install neuralspotx Installed 1 executable: nsx

Abbreviated examples: install with uv tool install neuralspotx, check with nsx doctor, create with nsx create-app, then nsx build, nsx flash and nsx view. Hardware output is illustrative. Follow Getting started for the complete instructions.

Modules

Find a capability. Add it to your app.

A familiar dependency workflow, applied to embedded firmware.

Once your first app builds, add capabilities through NSX modules. Like pip, Cargo or npm, NSX uses named dependencies, manifests and a lockfile, with compatibility checks for your target.

1. Find a capability

Search by function, then filter by board or toolchain. Inspect dependencies and declared compatibility.

2. Add it to your app

Add a module by name. NSX updates nsx.yml, resolves required dependencies and syncs their sources.

3. Build and keep the lock

Build your application and commit nsx.lock to record the resolved source set.
Inside your app directory
nsx module search audio
nsx module add nsx-audio
nsx build

Your project

Select modules. Keep control of the build.

The generated project keeps your sources, board support and dependencies together.

Create an app

Start with a board and template. NSX writes your manifest, CMake project and source files, then brings in the board baseline.

Lock the dependency set

Record resolved sources and hashes in nsx.lock. Sync the same set on another checkout and export it with nsx sbom.

Build with CMake

Use CMake and Ninja with the toolchain declared for your target. Your application remains an editable firmware project.

After checking your environment, follow build, flash and view to run the app. App layout explains which files you own and which NSX regenerates.

HELIA

Add the AI capabilities your app needs.

Ambiq's AI stack reaches your app the same way every other capability does: as a module you add and lock.

Runtime

heliaRT

nsx-helia-rt

LiteRT for Micro / TFLM-compatible runtime with Reference, CMSIS-NN, and heliaCORE backends.

Kernels

heliaCORE

ns-cmsis-nn

Optimized neural-network kernel library for Ambiq SoCs.

Compiler

heliaAOT

helia-aot

Ahead-of-time compiler producing standalone C inference modules.

heliaRT and heliaCORE reach your app as the nsx-helia-rt and nsx-cmsis-nn modules; both also ship CMake and Zephyr integration in their public repositories, so choosing NSX here is not the only way to consume them.

Read more: the KWS Inference example declares the nsx-helia-rt module and builds like any other app here.

Explore the SDK

Find the modules and board support for your app.

The catalog is generated from registry and manifest data. Compatibility entries describe declared support.

Registry modules

50

Board descriptors

17

SoC families

11

Toolchains

3

Example apps

10

The packaged registry lists 50 modules. NSX ships 17 board descriptors across 11 SoC families, declaring 3 toolchains between them, and this repository carries 10 example apps.

Use the module catalog and board matrix to inspect the declarations, then read Boards and targets to configure your app. Check the module and example documentation for validation on your target.

In use

Start from a working example.

Explore complete NSX applications, with setup instructions and target support documented for each example.

Hello World

Build, flash and view your first board application.

Audio Capture

Capture microphone audio with the NSX audio module.

KWS Inference

Run keyword-spotting inference with TFLite Micro and CMSIS-NN kernels.
More examples

Documentation

Find your way around.

Get started with NSX, explore development guides and modules, or look up commands and APIs.

Getting started

Install NSX on macOS, Linux or Windows, check your environment and build your first board app.

User guide

Apps, modules, memory placement, startup and linker behavior, toolchains, and the concepts behind app generation.

Modules

The module registry: what each module provides, which SoCs and boards it declares compatibility with, and how to add it.

API reference

Every CLI command and option, the public Python API, and the schema of each manifest NSX reads.

Extend the SDK with custom modules or contribute a module. For automation, use the agent guidance, Markdown documentation and module catalog JSON.