Brawl · WebAssembly at the edge
Portable applications. A managed lifecycle.
Brawl brings WebAssembly application logic to constrained IoT devices. Package the code that changes as a portable module, connect it to defined device interfaces, and manage its delivery through the RIoT Secure platform.
Portable application logic
Let the application evolve. Keep a defined execution layer.
Brawl is RIoT Secure’s lightweight WebAssembly runtime for resource-constrained devices. Application logic is compiled into WASM bytecode and executed through the runtime’s host interfaces, providing a common application format across compatible hardware.
This separates the application module from the underlying device firmware. Business rules, local processing and AI-related application logic can evolve as smaller software units, while the platform supplies communication, delivery and lifecycle management.
A standard build target
From compiler to device execution.
Brawl runs WebAssembly bytecode delivered through RIoT Secure’s management platform. Developers can use compatible language compilers, optimisation tools such as wasm-opt, and WebAssembly development tooling to build application modules.
On the device, Brawl interprets the module and connects its imports to supported host functions. Hardware access is provided through those bindings, giving application code a defined interface to the capabilities of the target.
Portability across hardware
One module. Compatible targets.
Native firmware builds can produce very different binary sizes for the same application logic on different processors. Brawl uses WebAssembly bytecode as a common application format, so the module can move between supported targets that provide the required runtime and host bindings.
The Blink comparison below shows native builds of the same application on five targets. Binary size varies with the processor architecture, compiler and supporting libraries.
A compact application update
256 bytes. For the Blink module.
In the Blink example, the WebAssembly application module is just 256 bytes. That figure covers the module; the Brawl runtime and host libraries are separate.
A small module keeps the application update payload focused on the logic being changed. Download the WebAssembly text source and compiled binary below, including the host imports required to run this example.
Embedded execution
Device functions. Through defined bindings.
Brawl combines a WebAssembly software sandbox with native host bindings for device functions. GPIO, I²C, SPI, UART, 1-Wire and LED matrix interfaces give modules a defined way to access supported peripherals. Additional native functions can be exposed through the host when the application requires them.
The available interfaces, memory budget and device capabilities form part of the target configuration. Application portability depends on that contract, alongside the shared WebAssembly instruction format.
API reference
Explore the device interfaces.
Read the device API definitions, constants, error codes, implementation notes and C examples. Each reference opens here within the website, with navigation between interfaces.
The interfaces are brawl:device/gpio, brawl:device/i2c, brawl:device/onewire, brawl:device/spi, brawl:device/uart and brawl:device/matrix.
GPIO
Digital and analog I/O, pin capabilities, interrupts and PWM.
02I²C
I²C bus access and device communication.
031-Wire
1-Wire bus access and device operations.
04SPI
SPI bus configuration and data exchange.
05UART
Serial port configuration, reading and writing.
06LED matrix
Matrix dimensions, pixels and animation frames.
Intelligent edge applications
Let application logic evolve in the field.
Application logic and AI-related workflows can change more frequently than the device firmware beneath them. Brawl provides an execution layer for packaging that logic into compact, updatable WebAssembly modules.
This gives teams a separate application update unit for local processing, business rules and evolving edge functionality. The underlying runtime, host interfaces and firmware remain part of the device platform, with their own maintenance and validation requirements.
Delivery + management
Application updates. Inside the lifecycle.
Oasis supplies the management and delivery layer for Brawl applications, with µTLS providing efficient, encrypted device communication. Application modules can be managed as software versions within the surrounding device lifecycle.
Brawl’s WebAssembly sandbox and Fusion’s dedicated application microcontroller provide different execution boundaries. Teams can choose or combine those approaches around the hardware and application requirements while using the RIoT Secure lifecycle infrastructure.
Portability over time
A shared format. A longer development horizon.
WebAssembly gives development tools a common binary target, while host interfaces define what an application can do in each environment. As the WebAssembly and WASI ecosystem evolves, that separation provides a basis for carrying application logic across supported devices.
The same approach can support testing in simulators and digital-twin environments when matching host interfaces are implemented. New interfaces and execution capabilities remain choices for the target platform.
Build around your device
Plan the next application update.
Brawl connects portable application execution with device lifecycle management. Discuss your hardware, host interfaces, application logic and update requirements with the RIoT Secure team.