Compendium

Embedded / Firmware Languages Family Index

8 min read

Embedded / Firmware Languages Family Index

type: language-family-index family: embedded-firmware languages_catalogued: 17 tags: [language-reference, family-index, embedded, firmware, microcontroller, iot]

Embedded / Firmware Languages — Family Index

  • Type: Family index (encyclopedic)
  • Family: Embedded / firmware programming languages for microcontrollers and resource-constrained devices
  • Languages catalogued: 17
  • Last updated: 2026-05-07

Family overview

Embedded firmware languages occupy a cost-vs-features axis defined by ROM/RAM budgets that are commonly measured in tens of kilobytes, not megabytes. At one extreme sits bare-metal C — still the dominant choice in 2026 because every silicon vendor ships a C SDK, every RTOS (FreeRTOS, Zephyr, ThreadX, NuttX) is written in it, and the language imposes essentially zero runtime overhead. Slightly above C sit constrained subsets of C++ (the Arduino flavor, the now-EOL Mbed profile) and the modern memory-safe contender Rust via the embedded-hal/RTIC/embassy stack. At the other extreme sit interpreter-on-MCU bytecode VMs — MicroPython, CircuitPython, eLua / NodeMCU, MMBasic / PicoMite, embedded TinyScheme — that trade execution speed and roughly 256 KB of flash for live REPL development, dynamic typing, and a Python/Lua/BASIC programmer’s existing skill set.

What makes a language “embeddable” is a specific feature checklist, not just being small. It must support heap discipline (either no heap at all, a fixed-size pool, or a bounded GC), predictable timing (no stop-the-world pauses long enough to miss an interrupt deadline), static linking to a fixed flash address, direct hardware peripheral mapping (volatile MMIO, register bit-fields, interrupt vector binding), and toolchain support for cross-compilation to the target ISA (ARM Cortex-M, RISC-V, AVR, MSP430, Xtensa). A language that needs mmap, threads, file I/O, or a 64-bit address space is not embeddable in this sense — even if it is “small.”

The 2026 landscape shows three durable trends. First, Python on MCUs went mainstream: MicroPython 1.28 (April 2026) and CircuitPython 10.2 ship on every major Cortex-M0+, ESP32, and RP2040/RP2350 board. Second, Rust embedded crossed the production threshold — embedded-hal is the de-facto trait set, RTIC offers preemptive RTOS-grade scheduling with provable latency bounds, and embassy brings async/await to bare metal. Third, memory-safe alternatives gained official safety-critical traction: AdaCore + NVIDIA shipped Ada/SPARK firmware components for ISO-26262 automotive systems, and Rust is increasingly accepted in IEC-61508 and DO-178C contexts. Despite all this, C still writes most new firmware in 2026, because vendor SDKs, drivers, and BSPs are written in C and the inertia is enormous.

In our deep library

  • c — the dominant embedded language; the baseline against which every other entry on this page is measured.
  • cpp — Arduino’s flavor and the (deprecated) Mbed profile; embedded C++ usually disables exceptions, RTTI, and dynamic allocation.
  • rust — no_std mode, embedded-hal traits, RTIC, embassy; production-ready on Cortex-M and increasingly on RISC-V.
  • ada — Ravenscar profile and SPARK proofs in safety-critical embedded.
  • zig — emerging via MicroZig, which targets ARM Cortex-M, RISC-V, AVR, and MSP430.
  • lua — the host language eLua and NodeMCU embed.

Cross-reference: forth-and-concatenative for Forth dialects on MCUs (Mecrisp, FlashForth, AmForth, SwiftX); basics-and-teaching for the broader BASIC lineage that MMBasic and BBC BASIC for Pico descend from.

Tier 3 family table

LanguageFirst appearedTarget hardwareStatus (2026)URL
TinyGo2019ARM Cortex-M0+/M3/M4/M7, RP2040/RP2350, ESP32, AVR, RISC-V; 150+ boards; also WASM/WASIActive; v0.41 (April 2026) added Arduino UNO Q (hybrid Qualcomm MPU + STM32U585 MCU)https://tinygo.org/
MicroPython2014 (Damien George, Kickstarter)RP2040/RP2350, ESP32-C5/P4, STM32U5xx, nRF52, alif Ensemble, pyboard, Unix portActive; v1.28.0 (April 2026) added PEP 750 template strings, machine.CAN, alif machine.PWMhttps://micropython.org/
CircuitPython2017 (Adafruit fork of MicroPython 1.9.4)RP2040/RP2350, SAMD21/SAMD51, ESP32-S2/S3/C3, nRF52840, STM32Active; stable v10.2.0 (2026); largest community library bundle of any MCU languagehttps://circuitpython.org/
eC (Ecere)2004 (Jérôme Jacovella-St-Louis)Linux, Windows, macOS, FreeBSD, Android; transpiles to C; used in Ecere SDKActive but small; SDK updated April 2026; switching from Flex/Bison to recursive-descent parserhttps://ec-lang.org/
eLua (Embedded Lua)2008ARM7TDMI, Cortex-M3, AVR32, MIPS (e.g. Mizar32, LM3S, STR9, AT91SAM7)Largely dormant since ~2016; superseded by NodeMCU and MicroPython on hobbyist MCUshttps://eluaproject.net/
NodeMCU (ESP-Lua)2014ESP8266, ESP8285, ESP32 (Lua 5.1 originally; Lua 5.3 modern)Active community-maintained; original creators left in 2015; Lua 5.3 unifies ESP8266/ESP32https://nodemcu.readthedocs.io/
Mecrisp / Mecrisp-Stellaris2008 (Matthias Koch)MSP430, ARM Cortex-M0/M3/M4, RP2040/RP2350, RISC-V, MIPS, FPGA stack machinesActive; mecrisp-stellaris 2.6.3+ (2026); 3.x experimental branch in development; native-code optimizing Forth compilerhttps://mecrisp.sourceforge.net/
FlashForth2007 (Mikael Nordman)PIC18F, PIC24, dsPIC30/33, AVR Atmega (incl. Arduino UNO/MEGA)Active; v5.x; does NOT support MSP430 (use Mecrisp instead)https://flashforth.com/
Whitewater Forth (Whitewater Group / Symantec)mid-1980sDOS / 8086, embedded toolkitsDefunct; Whitewater Group acquired by Symantec 1992; product line discontinued. Listed for historical completeness — modern equivalents are SwiftX (FORTH, Inc.), Mecrisp, FlashForthhttps://en.wikipedia.org/wiki/Whitewater_Group
MMBasic / PicoMite2011 (Geoff Graham); PicoMite port 2021Microchip PIC32, then Raspberry Pi Pico (RP2040), Pico 2 (RP2350), Pico W, Pico 2 WActive; PicoMite v6.01.00 (2026); GUI/VGA variants; full Microsoft-compatible BASIC interpreter on a $4 MCUhttps://geoffg.net/picomite.html
Arduino C++ subset2005AVR, SAM, SAMD, nRF52, RP2040/RP2350, ESP32, STM32 (via cores)Active; the Arduino “language” is C++ minus exceptions and new/delete, plus setup()/loop() and the Wiring APIhttps://docs.arduino.cc/language-reference/
Mbed C++ profile2009 (Arm)ARM Cortex-M onlyDeprecated; EOL July 2026. Arm halted active maintenance and CI; community fork “Mbed CE” continues developmenthttps://os.mbed.com/blog/entry/Important-Update-on-Mbed/
Rust (embedded-hal / RTIC / embassy)2015 (Rust 1.0); embedded-hal 2018ARM Cortex-M (mature), RISC-V (growing), Xtensa (esp-rs), AVR (experimental)Production-ready in 2026; embedded-hal 1.0 stabilized; RTIC v2; embassy v0.3.5 with async/await on STM32, ESP32, RP2040https://github.com/rust-embedded/awesome-embedded-rust
Zephyr C (kernel + app)2016 (Linux Foundation; ex-Wind River Rocket)1000+ boards across ARM, RISC-V, ARC, Xtensa, x86, SPARCActive; largest contributor base of any RTOS as of 2025-26; recommends C17; the de-facto open-source RTOShttps://www.zephyrproject.org/
TinyScheme (embedded)2002 (Dimitrios Souflis)Any C host; used inside GIMP, embedded controllers, scripting hostsStable, low maintenance; <50 KB footprint; designed for embedding into C apps as a scripting interpreterhttps://tinyscheme.sourceforge.net/
TinyCC (TCC) for embedded2001 (Fabrice Bellard)i386, x86-64, ARM, ARM64, RISC-V; used as on-device JIT-style C compilerActive community fork (mob branch); occasionally embedded as a runtime C compiler on SBCs; not typical for sub-MB MCUshttps://bellard.org/tcc/
Ada / SPARK on embeddedAda 1983; SPARK 1988ARM Cortex-M (GNAT for ARM ELF), RISC-V, AVR (community), PowerPC, LEON SPARCActive; AdaCore at Embedded World 2026; NVIDIA shipping Ada/SPARK in ISO-26262 automotive firmware; Ravenscar profile is the embedded subsethttps://www.adacore.com/
BBC BASIC for Pico (PicoBB / BBCSDL)2021 (port; BBC BASIC itself 1981)Raspberry Pi Pico, Pico W, Pico 2, Pico 2 W (RP2040/RP2350)Active; Richard Russell’s BBCSDL upstream + Memotech-Bill PicoBB fork; v0.50 ships pre-built UF2 for Pico 2 / Pico 2 Whttps://memotech-bill.github.io/PicoBB/
MicroZig (Zig embedded)2021ARM Cortex-M, RISC-V, AVR, MSP430; Raspberry Pi, STMicro, Espressif, WCH, Microchip, Nordic, GigaDevice, NXPActive; release assets Feb 2026, codebase updated May 2026; type-safe register definitions auto-generated from vendor SVDhttps://microzig.tech/

Notable threads

  • Heap-vs-no-heap is the core design fork. C, Rust no_std, Ada Ravenscar, and Forth dialects (Mecrisp, FlashForth) deliberately have no heap, or a fixed-size static heap. MicroPython and CircuitPython have a bounded GC heap (typically 32–192 KB) with a non-moving collector tuned for short pauses. eLua and NodeMCU run a Lua incremental GC. The choice cascades into everything else: peripheral driver style, error-handling idioms, and what kinds of bugs are even possible.
  • The MicroPython ecosystem went horizontal in 2024-26. From 2024’s v1.23 onward, MicroPython added official ports for Espressif’s newer ESP32-C5/P4 (RISC-V), STMicro’s STM32U5xx (Cortex-M33 + TrustZone), and the alif Ensemble (Cortex-M55 + Ethos-U55 NPU). v1.28 (April 2026) added PEP 750 template strings — pulling MCU Python closer to mainline CPython feature parity than ever before.
  • CircuitPython’s library lead is hardware-driven, not language-driven. Adafruit pays full-time engineers to write CircuitPython drivers for every sensor and breakout board they sell. As of 2026 the Adafruit_CircuitPython_Bundle contains 600+ libraries — far more than MicroPython has — and that ecosystem is the actual reason hobbyists choose CircuitPython despite a slightly slower interpreter and stricter blocking I/O model.
  • TinyGo’s target list keeps growing because LLVM does the heavy lifting. TinyGo doesn’t write code generators; it lowers Go to LLVM IR and reuses the existing Cortex-M / RISC-V / AVR / WASM backends. v0.41 (April 2026) added Arduino UNO Q (Qualcomm Dragonwing QRB2210 + STM32U585 hybrid), demonstrating that adding a new MCU is mostly board-definition and peripheral-binding work, not compiler work.
  • Why C still dominates. Vendor BSPs ship in C. RTOSes ship in C (Zephyr, FreeRTOS, ThreadX, NuttX, RIOT). Hardware abstraction layers (CMSIS, ESP-IDF, STM32 HAL, Nordic SoftDevice) ship in C. Calling into any of these from Rust, Zig, or Ada requires extern "C" shims and unsafe-block reasoning. Until the vendor ecosystem itself shifts — which is starting at NVIDIA and a few automotive Tier 1s but is decades away from being industry-wide — C is the path of least resistance.
  • Rust’s growing share is concentrated in greenfield IoT and prosumer projects. The 2026 production-Rust embedded story is strongest where the firmware is written from scratch and the team has Rust expertise: smart-home gadgets, BLE peripherals, e-bike controllers, prosumer audio. It is weaker in industrial, automotive, and aerospace where existing C codebases, certified toolchains (KEIL, IAR, Green Hills), and qualification artifacts dominate. Ada/SPARK is the language gaining the most certified-domain ground because it already has the safety-critical pedigree.
  • Mbed’s death is informative. Mbed OS reaches official EOL in July 2026. Arm cited the success of Zephyr (Linux Foundation governance, vendor-neutral) and Arduino’s pivot away from Mbed-based cores as the reasons. The lesson: vendor-controlled embedded platforms struggle against vendor-neutral foundations, even when the vendor is the chip designer.

Citations

Graph View