AkiraPlatform

ZephyrOS Featured Project

The Expo for Embedded.

AkiraPlatform handles the OS, drivers, OTA pipeline, and security. You ship business logic — in C, Rust, or Python — as a single .wasm file, over the air.

Get Started View on GitHub

.wasmwrite once, run all

ESP32-S3 · ESP32-C6 · nRF54L15 · STM32 · RP2040 · AkiraConsole V3 OSHWA MD000003 (DIY edition)

v1.5.8 “C1ph3r” · v1.6.x in development

Platform

We handle the boring parts.

Stop writing drivers. Stop debugging OTA pipelines. Stop reading MCU datasheets. That's our job.

AkiraPlatform handles

You build

RTOS scheduling & memory management

Your application logic

HAL + peripheral drivers

Data processing & business rules

OTA pipeline (diff, sign, rollback, staged rollout)

Your WASM module (C / Rust / Python)

Secure boot & WASM sandboxing

Capability manifest (a JSON file)

Capability Guard — 60ns overhead per API call

Custom telemetry in AkiraHub

App signing & verification — Ed25519, optional post-quantum

Just akira sign

On-device ML runtime — WASI-NN + TFLite Micro

Your model (.aimodel)

Connectivity stack — BLE, LTE, LoRa, Wi-Fi

Nothing boring

Fleet management for 10,000+ devices

—

Write once. Run on ESP32-S3, nRF54L15, STM32. Same .wasm binary, every board.

One platform. Three layers.

AkiraOS runs on the chip. AkiraSDK turns your code into a .wasm. AkiraHub deploys and monitors it.

AkiraOS

The runtime. On the chip.

Zephyr RTOS kernel + WAMR WebAssembly runtime
Every app runs in a WASM sandbox — bad apps can't crash the device
Capability Guard: declare permissions in a manifest, enforced at runtime
Supports: ESP32-S3, ESP32-C6, nRF54L15, STM32
Native sim: test on your laptop before touching hardware

AkiraOS Docs →

AkiraSDK

Write code. Get a .wasm.

Header-only SDK + akira-cli (Go) — install via brew tap, scaffold with akira new
Write in C, Rust, or Python — compile to .wasm with one command
18 native API modules: GPIO, BLE, Display, Sensors, Storage, Net, OTA, AI…
pack → sign (Ed25519) → install — signed .akpkg, end to end
Publish to the app store (app.akiraos.dev) — browser install over USB / BT / WiFi

AkiraSDK on GitHub →

AkiraHub

Deploy to thousands. Monitor everything.

Web dashboard for fleet management
OTA: push a new .wasm to 10,000 devices with one click
Remote device revocation (brick/wipe) — one API call
Custom telemetry: register your own datapoints alongside system metrics
Alert rules, event history, device action API · White-label for OEMs

Open AkiraHub →

Developer Experience

From idea to deployed in five steps.

No RTOS knowledge. No custom toolchains. No firmware blobs. Just your logic in a .wasm file, running on real hardware.

temp_monitor/main.c

Write your app in C, Rust, or Python using AkiraSDK APIs. No RTOS knowledge required.

#include <akira_sdk.h>

void app_main(void) {
    akira_log("Starting temperature monitor", 30);

    while (1) {
        float temp = akira_sensor_read(SENSOR_TEMP);
        akira_telemetry_push("temperature", temp);
        akira_sleep_ms(5000);
    }
}

Edge AI · AkiraClaw

Run a model on the chip. Safely.

On-device ML inference inside the same WASM sandbox your apps run in — signed, capability-scoped, and attested. No cloud round-trip, no model leaving the device.

Inference in the sandbox

WASI-NN runs inside the WAMR runtime. Models load into a capability-scoped context — your app declares ai.infer in its manifest, nothing more is reachable.

Hardware-accelerated

TFLite Micro backend with ESP-NN acceleration on ESP32-S3 / C6, and CMSIS-NN on STM32 and nRF54L15. Per-target RAM and latency benchmarks in the docs.

Signed & attested

Models ship as signed .aimodel files (Ed25519, verified on load), stored encrypted at rest. Every inference emits an audit event — model hash + input hash — pushed to AkiraHub.

WASM AI API

aiinfer_* WASM API — load / run / unload
Pack a model alongside your app: akira pack --model model.tflite
ai.infer capability — scoped, declared in the manifest
Reference demos: “hey akira” keyword spotting + IMU anomaly detection

Edge AI guide →

hey_akira/main.c

#include <akira_ai.h>

aiinfer_ctx *m = aiinfer_load("kws.aimodel");

void on_audio(int16_t *pcm, size_t n) {
    float score = aiinfer_run(m, pcm, n);
    if (score > 0.9f)        // "hey akira"
        akira_app_launch("menu");
}

Security & Signing

Secure by default. Hardened for the regulated.

Every app is signed and sandboxed out of the box. When compliance demands more, AkiraPlatform layers enterprise security on top — as a Zephyr module, not a fork.

Open core · Apache 2.0

Secure by default

App signing on by default — Ed25519, in the .akpkg signature section
WASM sandbox — a bad app cannot crash the device
Capability Guard — permissions declared in a manifest, enforced at runtime
Secure boot + watchdog kill, every kill raises an audit event

AkiraPlatform module

Enterprise-hardened

Post-quantum signing — CRYSTALS-Dilithium-2 (FIPS 204), opt-in, dual-sig capable
HSM key store — ATECC608B or SE050, zero private keys in firmware
Encrypted NVS at rest — ESP32-S3 flash encryption, key in eFuse
Per-app network isolation + OEM-root-CA app allowlist
Secure factory provisioning — burn key, issue device cert, register with Hub

SBOMCycloneDX 1.4 — EU CRA ready

PSA Certified L1gap analysis published

IEC 62443-4-2requirement-by-feature mapping

Compliance & enterprise

Hardware

Runs on the hardware you're already using.

Your app is a .wasm file. It runs on every supported board — no recompile, no reflash, no surprises.

Tier 1 — Full support

ESP32-S3

Dual-core Xtensa LX7 · Wi-Fi + BLE · 512KB RAM

Tier 1 — Full support

ESP32-C6

RISC-V · Wi-Fi 6 + BLE + 802.15.4 · 512KB RAM

Tier 1 — Full support

nRF54L15

ARM Cortex-M33 · BLE 5.4 · Ultra-low power

Tier 2 — Supported

STM32

ARM Cortex-M family · broad peripheral support

Tier 2 — Supported

RP2040

Dual-core Cortex-M0+ · Raspberry Pi silicon · low-cost target

Reference — Dev board

AkiraConsole V3

ESP32-S3 · Pre-flashed AkiraOS · DIY edition open-source certified · Production version sold separately

OSHWA MD000003 · DIY Edition · Prod version separate

Bring your own board.

AkiraOS ships as a Zephyr west module (zephyr/module.yml). Start from the boards/template/ BSP scaffold, implement GPIO / SPI / I2C / PSRAM / display against the HAL porting guide, and bring up AkiraOS on new silicon in about a week. Minimum target: 128KB SRAM, 512KB flash.

HAL porting guide

Full board support list

Pricing