AI-Powered IDE for Embedded Development

IOcomposer is a bare-metal embedded IDE with AI-powered code generation. It provides a complete firmware development environment — from project creation through compile, flash, and JTAG/SWD debug — for ARM Cortex-M microcontrollers. Supported today: Nordic nRF52/nRF54. In progress: STM32, NXP, Renesas, Microchip, and RISC-V targets.

IOcomposer targets ARM Cortex-M today, with RISC-V targets in progress. Supported MCU families today include Nordic nRF52832, nRF52840, and nRF54L15. Preview support is available for STM32 (ST), Renesas RA, and Microchip SAM/PIC32 families. NXP LPC/i.MX RT and additional RISC-V targets are in progress. Nordic is the primary supported vendor today, with BLE SoftDevice integration for nRF52 (S132/S140) and nRF54 (S145).

No. IOcomposer takes a bare-metal approach using a lightweight hardware abstraction layer and Nordic's baremetal SDK (sdk-nrf-bm). You write directly against hardware registers and a thin HAL, with SoftDevice BLE stacks integrated natively. nRF Connect SDK provides a full RTOS environment with Zephyr, Device Tree, Kconfig, and CMake — powerful for complex, multi-threaded applications. IOcomposer targets a different use case: projects where direct hardware control, minimal overhead, and fast board porting matter more than RTOS features. One MCU configuration works on any board with that chip, and the AI reads your local SDK files to generate code that compiles without modification.

Yes. IOcomposer supports the Nordic nRF54L15 with bare-metal development using the sdk-nrf-bm SDK and the S145 SoftDevice BLE stack. You can create BLE peripheral and central projects for nRF54L15 with direct hardware access and a managed build system.

Arduino is designed for beginners with simplified APIs and no debug support. IOcomposer provides professional embedded tools — JTAG/SWD debugging with breakpoints, register and memory views, direct MCU register access, BLE SoftDevice integration, and AI-assisted code generation that reads your actual SDK headers. IOcomposer is built for makers and developers who have outgrown Arduino and need real hardware debugging and vendor SDK access.

General-purpose AI tools like Copilot and Cursor are trained on web and application code, not vendor SDKs or MCU register maps. They generate firmware that looks plausible but references structs that don't exist or calls functions with wrong signatures. IOcomposer's AI reads your actual, locally installed SDK headers before generating code — so the output compiles against your real SDK. On top of that, IOcomposer integrates build, flash, and JTAG/SWD debug into a single workflow. With VS Code + Cortex-Debug, you're manually configuring launch.json, OpenOCD scripts, and SVD files yourself.

Yes. IOcomposer targets the MCU directly rather than requiring board definitions or BSP files. If your custom board uses a supported MCU (such as nRF52840 or nRF54L15), you configure pin assignments in your firmware code and flash directly. No Device Tree overlay or board file is needed.

IOcomposer uses GCC ARM (arm-none-eabi-gcc) and GCC RISC-V toolchains for compilation, and OpenOCD for JTAG/SWD flashing and debugging. It supports standard debug probes including J-Link, CMSIS-DAP, and ST-Link. The entire toolchain is installed automatically by the one-command installer.

The AI indexes your locally installed vendor SDK and reads your project's header files, framework sources, and configuration before generating code. You can also add your own code libraries to the knowledge base — proprietary drivers, internal frameworks, or shared middleware — so the AI works with your codebase, not just the vendor's. It can create projects, add peripherals (UART, SPI, I2C, BLE services), fix build errors, and open files directly in the editor.

Yes. You can add your proprietary drivers, internal frameworks, shared middleware, or any code library to IOcomposer's AI knowledge base. The AI then generates code that uses your APIs, naming conventions, and patterns — not just the vendor SDK. This works the same way vendor SDKs are integrated: your library becomes part of what the AI knows when writing and reviewing code.

No. Your source code, project files, and entire codebase stay on your machine — IOcomposer does not upload or store them. The AI builds a local index of your SDK and project; only your chat query and the minimal relevant snippets needed to answer it are sent to the AI model for processing. Nothing is stored server-side, and chat sessions are discarded when you exit.

IOcomposer runs on macOS, Linux, and Windows. A one-command installer sets up the IDE, ARM and RISC-V toolchains, OpenOCD, vendor SDKs, and the AI plugin — typically in about 10–15 minutes on a fresh machine.

Yes — IOcomposer is in free preview right now. The IDE with full build, flash, and debug capabilities is free, and all Advanced AI features are unlocked for every account during the preview period. After launch, AI features will have a free tier (20 queries/month) and paid plans starting at $19.95/month.

Install the IDE, then open Preferences → IOcomposer → Account and create a free account (or sign in) to enable AI Chat. No payment is required for the free tier.

IOsonata is an open-source, ISA-agnostic embedded firmware framework that provides a consistent API across ARM Cortex-M and RISC-V microcontrollers from multiple vendors. It reimplements core peripherals (UART, I2C, SPI, timers, PWM, GPIO, interrupts) with a unified interface while calling vendor HAL for less common peripherals. IOcomposer is the recommended IDE for IOsonata development.

IOcomposer is purpose-built for nRF52840 bare-metal development. It integrates the Nordic bare-metal SDK (sdk-nrf-bm), SoftDevice S140 BLE stack, GCC ARM toolchain, and OpenOCD debugger in a single install. Unlike VS Code + Cortex-Debug (which requires manual configuration of launch.json, OpenOCD scripts, and SVD files) or nRF Connect SDK (which requires Zephyr, Device Tree, and CMake), IOcomposer gives you a direct path from project creation to JTAG debug on nRF52840 hardware in about 15 minutes. The AI assistant reads your installed SDK headers to generate code that compiles without modification.

IOcomposer is designed for exactly this. It uses Nordic's bare-metal SDK (sdk-nrf-bm) with direct SoftDevice integration — S132 for nRF52832, S140 for nRF52840 — without requiring Zephyr, nRF Connect SDK, Device Tree, or Kconfig. You write directly against hardware registers and the SoftDevice API. IOcomposer's project wizard generates a fully functional BLE peripheral or central firmware that builds and flashes to your board. No RTOS, no CMake, no Device Tree overlays.

nRF Connect SDK (NCS) is Nordic's full RTOS-based development environment built on Zephyr. It's the right choice for complex, multi-threaded applications that need Zephyr services, Bluetooth mesh, Matter, or Thread. IOcomposer is the right choice when you want direct hardware control, minimal firmware footprint, fast board porting, and no RTOS overhead. The key trade-off: NCS has broader protocol support and Nordic's full backing; IOcomposer offers simpler tooling, faster custom board porting (change a few pin #defines and recompile), and AI code generation grounded on the actual SDK headers. Many developers use NCS for production BLE stacks and IOcomposer for rapid hardware bring-up and prototyping on custom boards.