AkiraOS Logo
ZephyrOS Featured Project

The Modular WASM-based RTOS for the Edge

Build hardware-agnostic applications on Zephyr RTOS with a WASM runtime. Ship to any MCU. Secured by post-quantum cryptography.

Core Technology

Everything you need at the edge

A vertically integrated stack from kernel to cloud, designed for constrained devices with uncompromising security.

Zephyr RTOS

Powered by Zephyr

Built on the battle-tested Zephyr RTOS kernel. Full POSIX compatibility, real-time scheduling, and support for 600+ boards out of the box.

Real-TimePOSIX600+ Boards
Learn more

WASM Runtime

WAMR

Deploy hardware-agnostic WebAssembly modules to any microcontroller. Write once in C, Rust, or AssemblyScript -- run everywhere.

PortableSandboxedMulti-Language
Learn more

Security

Post-Quantum by Default

CRYSTALS-Kyber key encapsulation and CRYSTALS-Dilithium signatures are enabled at the transport layer. Future-proof your fleet today.

KyberDilithiumZero Trust
Learn more
Products

Built for builders

From your first prototype to planet-scale fleets, AkiraOS products cover the full lifecycle.

AkiraConsole
Available

AkiraConsole

The Operator Terminal

A handheld operator terminal for provisioning, monitoring, and debugging your AkiraOS edge devices. Compact, tactile, purpose-built. Code, Play, Create.

Live telemetry
OTA updates
WASM inspector
Fleet logs
Explore Product
Coming Soon

AkiraMicro

Hardware Reference Platform

A purpose-built development board featuring an ESP32-S3 with integrated secure element, hardware RNG, and pre-flashed AkiraOS. The fastest path from idea to production.

ESP32-S3
Secure Element
Hardware RNG
Pre-flashed
Join Waitlist
Developer Experience

From source to silicon in three steps

Write in Rust, C, or AssemblyScript. Compile to WASM. Deploy via WiFi. Monitor in real-time. No custom toolchains required.

Choose Your Language

sensor-reader/src/main.rs
#[link(wasm_import_module = "akira")]
extern "C" {
    fn log(msg: *const u8, len: u32);
    fn sensor_read(sensor_id: u32, buffer: *mut u8, len: u32) -> i32;
    fn get_time_ms() -> u64;
}

#[no_mangle]
pub extern "C" fn _start() {
    unsafe {
        let msg = b"Sensor reader v1.0 starting...";
        log(msg.as_ptr(), msg.len() as u32);
        
        let mut data = [0u8; 64];
        loop {
            if sensor_read(0, data.as_mut_ptr(), data.len() as u32) > 0 {
                let msg = b"Temperature: 24.5°C";
                log(msg.as_ptr(), msg.len() as u32);
            }
            wait(5000); // Every 5 seconds
        }
    }
}

fn wait(ms: u64) {
    unsafe {
        let target = get_time_ms() + ms;
        while get_time_ms() < target {}
    }
}

Quick Start Workflow

Step 1: Build
# Compile Rust to WASM
./build_wasm_app.sh [options] <source_files...>

# Verify size (should be < 15KB)
ls -lh app.wasm

Ready to build? Check out the full documentation and examples.