Moddable SDK 8.3.1

Moddable SDK 8.3.1 is an interim release. It corrects issues that impact developers using the Moddable SDK with TypeScript and wasm. Full release notes will be included with the August 2026 Moddable SDK release.

Moddable SDK 8.3.0

Moddable SDK 8.3 contains improvements made between June 3, 2026, and July 3, 2026.

This release of the Moddable SDK includes contributions from many developers building with Embedded JavaScript in extremely diverse ways. Thank you to everyone for sharing your experience, expertise, and time with the community.

ECMA-419 Fourth Edition is an International Standard!

The Ecma General Assembly of June 2026 officially declared ECMA-419 Fourth Edition as an international standard. The Moddable team has been deeply involved in the creation of this standard, collaborating with many other organizations and individuals, in Ecma TC53.

You can read the complete standard here. Even if you aren't the kind of person who regularly reads standards, it is worth a look to appreciate just the breadth and depth of APIs that are available to Embedded JavaScript developers.

ECMA-419 Fourth Edition is significant for several reasons:

• Standard Bluetooth LE JavaScript APIs for both central and peripheral (client and server) with broad functionality, significantly more capabilities than Web Bluetooth. Products can implement their Bluetooth support using JavaScript using a tiny fraction of the code required to do the same in C.
• Standard DNS-SD in JavaScript allows products to claim local names, advertise their network services, and discover compatible network services.
• Numerous refinements to make Embedded JavaScript developers even more powerful.
• The standard itself has been fully reworked in Ecmarkup, just like the JavaScript standard, ECMA-262. This makes the standard easier to navigate with integrated search, smart highlighting, hierarchical table of contents, cleaner formatting, pinning, and faster loading.
• TC53 is picking up the pace. Each previous edition required two years to prepare; the fourth edition took just one. We are optimistic that the adoption of Ecmarkup will allow the committee to maintain this shorter cadence.

All the new features in ECMA-419 Fourth Edition are already implemented in the Moddable SDK. You can start using them today.

Explicit Resource Management Lands

The Explicit Resource Management APIs are a set of new tools for ensuring that objects release their resources immediately when they are no longer needed. This capability is especially relevant to Embedded JavaScript developers because we typically work on resource-constrained devices.

The JavaScript language committee, TC39, recently advanced the Explicit Resource Management proposal to Stage 4, which means it will be incorporated into the language standard. Moddable implemented the features and has been testing them behind a flag. In this release, they are now enabled by default and available for everyone to use. The V8 team published a nice introduction. These features are also available in TypeScript.

The simplest way to use Explicit Resource Management is with the using keyword. Choose it in place of let or const for a disposable object so the instance is automatically disposed when it goes out of scope. In this example, there's no call to close() the file because that is taken care of automatically, even when the read() method throws an exception.

function loadFile(path) {
	using file = device.file.openFile({path});
	return file.read(file.status().size);
}

Without Explicit Resource Management, the function is much more complex:

function loadFile(path) {
	const file = device.file.openFile({path});
	try {
		const result = file.read(file.status().size);
		file.close();
		return result;
	}
	catch (e) {
		file.close();
		throw e;
	}
}

All ECMA-419 classes in the Moddable SDK can be used with Explicit Resource Manager, as they alias the ECMA-419 Base Class Patterns close() method to Explicit Resource Management's [Symbol.dispose]() method.

ESP-IDF Update Pending

ESP-IDF 6.0.2 is live. It fixes one known issue with BLE that Moddable SDK developers have encounterered. We've successfully tested it with the Moddable SDK and plan to migrate to it in our next Moddable SDK release.

Details

• ECMA-419
  • All ECMA-419 classes support Explicit Resource Management by aliasing [Symbol.dispose] to close().
  • crypt/digest implementations for PSA (ESP32, eventually Zephyr) and KCL (any target). Note that this API is not yet stable.
  • UDP on macOS includes error codes in exceptions.
  • Serial on macOS issues writable before readable.
  • Asynchronous I2C
    • close() fix #1620 (reported by @stc1988).
    • writeRead() implemented.
  • BLE Peripheral implements remoteAddress property and disconnect() method (suggested by @stc1988). These are 5th Edition features.
• Devices
  • Pebble / Alloy
    • Health module provides full access to Pebble OS health_service APIs.
    • Poco origin fixes #1626 (reported by @EvanDSanders).
    • Add process() to transform command lists (requested by @FeralFox) #1632 (Example in Pebble-Examples repository)
    • Fixes to header handling in proxy #1630 (contributed by @jplexer)
    • Button module rewritten to use Pebble OS click recognizers Moddable-OpenSource/pebble-examples#12 (suggested by @vincentezw)
    • Reenable logging to app console when not attached to debugger #1648 (reported by @jplexer)
  • Moddable Display 6 build fixes
  • ESP32, Pebble, and Pico set context correctly for touch
  • ESP32, ESP8266, Pico, and Zephyr continue start-up after attempt to connect to Wi-Fi fails #1644 (reported by @stc1988)
  • Windows now uses TimerQueue for Timer module to support longer timeouts and more timers #1638 (requested by @amao-cbw)
  • ESP32
    • More mod support for M5 devices (contributed by @stc1988)
    • M5Stack Core2 updates to use ECMA-419 touch, power peripheral, and RTC #1624 (contributed by @stc1988)
• XS JavaScript engine
  • Enable Explicit Resource Management on all targets.
    • Conformance improvements for Explicit Resource Management.
  • xsmcGet(), xsmcGetIndex(), xsmcGetAt() return boolean indicating whether property was found. Streamlines a common pattern in ECMA-419 constructors
  • Native stack overflow no longer reported as JavaScript stack overflow.
  • String trim*() methods only copy if something is trimmed.
  • Array.from() and Array.fromAsync() don't throw on an undefined mapper argument #1645 (reported by @d01c2).
  • Conformance improvements for immutable ArrayBuffer proposal (reported by @erights, thanks to @gibson402).
  • Fix for await in module body (top level).
• Modules
  • EventSource web-compatibility improvements
  • CO5300 Display Driver
    • 180-degree rotation optimization #1623 (contributed by @kitazaki)
    • Allow some async transmission of pixels in 90/270 rotation cases
  • Add GDEY037T03 ePaper display driver #1636 (contributed by @jplexer)
  • Modules module supports namespace import
  • Commodetto
    • Large glyphs render correctly after fixing overflow in font engine #1631 (reported by @FeralFox)
    • When dividing buffer for async transmission, ensure buffer height remains mulitple of two (fixes garbage in CO5300 driver which requires height to be a multiple of two)
    • Reject unsupported PNG files to avoid unexpected state #1639 (contributed by @rootvector2)
    • BMF parsers updated to defend against invalid data #1643 (contributed by @rootvector2)
  • zlib inflate's push() method accepts optional output buffer to let the caller manage output buffers and output size
  • ChatAudioIO uses a larger native stack for the chat worker (default no longer enough in ESP-IDF v6) (reported by @stc1988) #1635
  • Base64 module (deprecated) memory safety vulnerability fixed #1627 (contributed by @alhudz)
  • DNS parser hardened with additional bounds checks #1628 (contributed by @rootvector2)
  • TextDecoder hardened against invalid data #1637 (contributed by @rootvector2)
  • GT911 touch driver
    • Use writeRead() to minimize I2C transactions
    • Implement length configuration to indicate the maximum number of simultaneous touch points
    • Add asynchronous version of driver using Async I2C
    • Add asynchronous version of driver using micro worker
  • FT6206 touch driver correctly merges configure() options #1646 (contributed by @stc1988)
• TypeScript
  • Typings now support multiple versions of TypeScript compiler
  • WebSocket typings collision fixed #1629 (reported by @imax9000)
  • Typings updated to sync with API changes in this release
• Tools
  • mcpack automatically creates EventSource global if used by packages.
  • testmc now uses ECMA-419 Wi-Fi.
  • xst supports d8 bundle format to enable module fuzzing with Fuzzilli.
• Examples
  • Home Assistant examples show clearer error messages when authorization fails (e.g. token isn't configured).
  • New package/eventsource example (in TypeScript).
  • New bmi270 examples #1640 (contributed by @stc1988).

Contact Us

If you have questions or suggestions about anything here, please reach out:

• Start a new Discussion on our GitHub repository.
• Drop by our Gitter to chat.
• Contact us on X / Twitter at @moddabletech.

Moddable SDK 8.2.3

Moddable SDK 8.2.3 corrects a bug inadvertently introduced in 8.2.2 that caused rendering failures on many devices. Thank you to @stc1988 for reporting this so quickly.

Full release notes will be included with the July 2026 Moddable SDK release.

Moddable SDK 8.2.2

Moddable SDK 8.2.2 is an interim release. Full release notes will be included with the July 2026 Moddable SDK release.

• TypeScript declarations improvements
• CO5300 display driver optimizations
• Alloy enhancements and fixes for Pebble OS
• Memory safety improvements
• Windows Timer upgrade to TimerQueue
• M5Stack Core2 update

Moddable SDK 8.2.0

Moddable SDK 8.2 contains improvements made between May 7, 2026, and June 3, 2026.

It has been another busy month in the Embedded JavaScript universe. Thanks to the many developers who have shared their experiences, knowledge, and time to help make the Moddable SDK better for everyone. Read on to learn how we're making Embedded JavaScript the most reliable, powerful, and easiest way to create software for embedded devices.

xsbug for Pebble Alloy

Developing apps for Pebble watches using Alloy is about to get a lot easier. We're bringing support for xsbug, our powerful JavaScript debugger, to Pebble. We've integrated support for the XS debugging protocol for Pebble into this release, transporting all communication between Pebble and xsbug over Pebble's internal messaging infrastructure. This means that all capabilities of xsbug, including conditional breakpoints, function breakpoints, an interactive REPL, tracepoints, and advanced performance profiling, will soon be available to Pebble developers to debug and optimize their applications. Stay tuned for an update to the Pebble SDK that includes JavaScript debugging.

Home Assistant

Home Assistant support has landed in the Moddable SDK. You can use it to turn any microcontroller into a home controller. If you aren't already familiar, Home Assistant is the popular open-source solution for managing all the connected devices in your home. It provides vendor-neutral management of devices across IoT ecosystems and works remarkably well. This release of the Moddable SDK supports the Home Assistant WebSocket API using the official npm home-assistant-js-websocket package to provide low-latency, lightweight device status and control.

We've added four new examples to get you started:

1. Discover lists all the devices your Home Assistant installation has found.
2. Blink turns a lightbulb on and off based on a timer.
3. Blink-ts is exactly like Blink, but in TypeScript.
4. Button turns a lightbulb on and off using a button on your development board.

Lots of ECMA-419

We are pushing hard to migrate the Moddable SDK to standard ECMA-419 Embedded JavaScript APIs. This means deprecating many of our original APIs, including "pins" for IO and network/wifi module. This release uses ECMA-419 Wi-Fi for most microcontroller hosts. In addition to a simpler, modern API, this brings support for static IP addresses and hostnames.

The 4th Edition of ECMA-419 is expected to be ratified later this month. It includes extensions to Digital and DigitalBank for initialValue and activeLow options. These options are supported in this Moddable SDK, and our modules and examples have been updated to use them.

While we don't have a precise timeline for cutting completely over to ECMA-419 APIs, the work is active and we hope to complete it in the coming months. We recommend migrating your projects. If you have questions, please reach out to us at the contacts below.

Asynchronous Touch Driver

An underappreciated feature of ECMA-419 is fully asynchronous I²C and SMBus operations. Clock stretching is a feature of I²C and SMBus that allows a peripheral to take time responding to requests. Using synchronous requests, this can block. With some touch drivers, the profiler in xsbug shows that this can take between 5 and 10% of total execution time. Asynchronous I²C and SMBus drop this to almost zero. This release of the Moddable SDK refreshes the asynchronous version of our FT6206 touch driver and makes it the default on the M5Stack Core S3, reducing overall latency and giving back more CPU time to apps.

RGB565 Big-Endian Pixels

Just about every microcontroller is little-endian (even those that support big-endian run almost exclusively in little-endian mode). This makes it natural and efficient for graphics engines to render pixels in little-endian format. Unfortunately, for historical reasons, most frame buffers expect pixels in big-endian format. In some cases, the microcontroller has hardware support to convert little-endian pixels to big-endian with no overhead. Unfortunately, this isn't always the case – for example, the new CO5300 driver and Zephyr display drivers introduce measurable overhead, reducing the frame rate. This release of the Moddable SDK has the ability to render pixels in RGB565 big-endian format, eliminating the need for conversion. Big-endian pixels are ever so slightly slower to render on little-endian microcontrollers. But when the driver requires big-endian pixels and no hardware conversion is available, big-endian can be significantly faster overall.

There's another factor: cameras. Because frame buffers tend to want big-endian pixels, cameras tend to provide big-endian pixels. For devices displaying camera input, big-endian pixels can be an even bigger boost. We've seen meaningful increases in frame rate for cameras using big-endian pixels. This release makes RGB565 big-endian pixels the default for M5Stack CoreS3 to better support its built-in camera and for the Waveshare Amoled 206 to improve performance of its CO5300 display driver.

Details

The details that follow do not include the items covered above.

• Modules
  • Poco
    • Fix crash on missing glyph (reported by @stc1988) #1606
    • Missing accented characters substitute unaccented character
    • Implement RGB565 Big Endian rendering (faster for some display drivers)
  • Crypt
    • AES optimizations
    • Reduce GC churn by reducing re/allocations
  • Audio Out
    • Fix Pico warnings (reported by @stc1988) #1595
  • Drivers
    • CO5300 display driver
      • Optimized rotation support (contributed by @kitazaki) #1605
      • Supports RGB565 BE pixels
    • FT6206 asynchronous driver working again and synchronized with synchronous version
    • Add Si12T touch driver (contributed by @stc1988)
  • ChatAudioIO
    • Add support for Gemini 3.1 Flash Live and GPT Realtime 2 (contributed by @stc1988)
• ECMA-419
  • Audio Out on ESP32 eliminates block during write by only using full DMA buffers
  • File module conformance improvements and bug fixes
  • ECMA-419 Wi-Fi
    • Used by all MCU hosts to establish Wi-Fi connection (setup/network)
    • Supports static IP address
    • Supports setting hostname
  • ECMA-419 Ethernet
    • Supports static IP address
    • Supports setting hostname
  • ECMA-419 Digital and Digital Bank
    • Support activeLow to automatically invert (previously only on Zephyr)
    • Support initialValue to set initial state without glitch
  • ECMA-419 HTTP Server sets correct status text
  • Asynchronous I²C and SMBus are working again
  • I²C on ESP32 is again using persistent device & bus – more efficient
  • WebSocket defines readyState constants for web compatibility
• Platforms
  • Pebble
    • Enable debugging support using xsbug in the host
    • Instrumentation improvements
    • Integrate watch.exit() method (Contributed by @devsnek) #1617
    • Fix build on NixOS (contributed by @alesya-h) #1614
    • FFI hardening
    • Poco renders 2-bit gray BMF fonts Moddable-OpenSource/pebble-examples#7
  • ESP32
    • M5Stick and M5Stick Cplus
      • Use ECMA-419 drivers (contributed by @stc1988)
      • Optional power button support
    • M5Stack CoreS3 uses Big Endian 565 Pixels (faster with camera) and async FT6206 touch driver (non-blocking)
    • M5AtomS3R supports BMI270 IMU (contributed by @kitazaki)
    • Waveshare Amoled 206
      • Uses RGB565 BE pixels (faster)
      • Defines screen.corner so apps can adapt
    • No longer providing a default for SPI pins to eliminate surprising collisions. This will break existing code that depends on the defaults, but we haven't seen that yet.
  • Pico
    • ws_round and ws_round_touch targets support QMI8658 IMU (Contributed by @stc1988)
  • Web Assembly
    • Promises now work (Contributed by @meganetaaan)
    • Build fixes, support for latest emscripten #1615
• XS JavaScript engine
  • Parser memory overhead reduced – smaller and faster
  • ArrayBuffer transfer* functions do not use species constructor (conformance). Note that this is a potential security vulnerability and consequently a recommended update to all production releases with these APIs enabled.
• Examples
  • ECMA-419 OTA push using HTTP server
  • Two new examples using QMI8658 IMU (contributed by @stc1988)
  • New suite of Home Assistant examples
    • blink
    • blink-ts
    • button
    • discover
• TypeScript
  • ECMA-419 HTTP Server typings added
  • ECMA-419 Wi-Fi typings added
  • ECMA-419 Update (OTA) typings added
  • ECMA-419 DNS-SD typings added
  • screen adds optional frameRate, syncFrame, and command()
  • FFI typings added
  • JSON modules now work with TypeScript (at least in some cases..)
  • Add typings/tsconfig.base.json for convenience running tsc outside mcconfig and mcrun. Useful for `mcpac...

Moddable SDK 8.1.1

Moddable SDK 8.1.1 is an interim release to address ecosystem issues introduced with 8.1. Full release notes will be included with the June Moddable SDK release.

• Fix crash on missing glyph in Piu (introduced by substitution changes)
• mcpack supports external subplatforms (contributed by @HipsterBrown)
• Quiet (spurious) use of uninitialized variable error in Poco on Pebble OS builds
• Fixes Pico build errors and warnings

Moddable SDK 8.1.0

Moddable SDK 8.1 contains improvements made between April 13, 2026 and May 6, 2026.

New Foreign Function Interface (FFI)

We've created a new Foreign Function Interface for our XS JavaScript engine. The XS in C API already lets developers bridge between JavaScript and C code. XS in C isn't going away. It allows native C code to implement JavaScript language features. Our new FFI has a different focus, calling C functions from JavaScript as directly as possible. It doesn't try to make the C functions look like JavaScript. As a result, the new FFI makes it much easier to bind C functions to JavaScript – there's no glue code at all for developers to write.

If your goal is to implement a JavaScript-style API in C, continue using XS in C. If you need to call a simple C function, use the FFI. In some situations, you might take a hybrid approach of wrapping the FFI calls in a JavaScript class to provide a more natural JavaScript-style API. Our FFI documentation includes examples of how to do this.

The motivation for the FFI came from Pebble Alloy developers, who wanted an easy way to invoke C code from their JavaScript code. We were so pleased with the result that we decided to make it available to developers on all platforms. ESP32 developers should check out the new ESP-IDF FFI example that calls ESP-IDF GPIO functions directly from JavaScript.

Raspberry Pi Pico SDK v2.2 and More Devices

The Raspberry Pi Pico is a perfect fit for Embedded JavaScript with the Moddable SDK. The CPU is reasonably powerful and fast. The hardware is inexpensive. There's enough memory for ambitious projects. And many fun development boards are available.

With this release, we've moved to v2.2 of the Raspberry Pi Pico SDK. Along the way, we fixed some issues that crept in and added support for more standard ECMA-419 APIs. We also added support for several development boards:

• Pico 2 W
• Pimoroni tiny2350
• Seeed Studio XIAO-RP2350
• Waveshare RP2350 Touch LCD 1.28
• Waveshare RP2350 Touch 1.69
• Waveshare RP2350 Touch 2.8

More Pebble OS APIs for Alloy

We continue to rapidly evolve Pebble OS integration for Alloy. This release includes support for the Pebble OS APIs most requested by Alloy developers.

• Dictation
• Wakeup
• App focus events
• Vibes
• Backlight
• Model & firmware version
• Launch reason

As usual, Moddable's Pebble Examples repo is a great place to get to know these Pebble APIs.

We've added support for Pebble color names, so Poco developers can write render.makeColor("dark candy apple red") and Piu developers can use "medium spring green" anywhere a Piu accepts a color. Thanks to the Pebble community for suggesting this feature.

As noted above, our new Foreign Function Interface lets Pebble developers easily mix JavaScript and C code in their apps.

Note: These capabilities will be integrated into a future Pebble firmware and Pebble SDK releases.

External Subplatforms

In the Moddable SDK each development board is supported by a "subplatform," . For example, the "ESP32" platform includes support for "moddable_six" and "m5stack_cores3" subplatforms. All subplatform support has always been built into the Moddable SDK. Occassionaly this is inconvenient, for example if you are build a new board that won't need a public subplatform yet.

We've extended the mcconfig command line to support subplatforms hosted outside the Moddable SDK repository. To use the feature, follow the platform identifier (e.g. esp32) with a colon and the path of the directory containing your subplatform manifest:

mcconfig -d -m -p esp32:$HOME/Projects/myboard

More Extensive ECMA-419 Support

We're picking up the pace of our migration to ECMA-419 standard APIs. Our hope is to complete the transition in the coming months. This release includes several new modules that implement ECMA-419 APIs:

• Wi-Fi for ESP32, ESP8266, and Raspberry Pi Pico
• Ethernet for ESP32
• Key Value storage for ESP8266, nRF52, and Raspberry Pi Pico

Contributions by @stc1988 migrate several sensor drivers used on ESP32 devices to use the ECMA-419 sensor class pattern.

Details

The details that follow do not include the items covered above.

• Modules
  • Commodetto
    • bufferOut - support use as ECMA-419 Display
    • Missing character substitution – Substitute ASCII sequences for Unicode glyphs unavailable in the current font. For example, long dash becomes simple ASCII dash, © becomes (c), smart quotes become regular quotes, and ellipsis … becomes three periods .... This improves readability of LLM generated text. No JavaScript API changes.
    • Host can provide color name strings to be available via makeColor()
  • Piu
    • Performs missing character substitution like Commodetto (see above).
    • Supports host-provided color name strings (in addition to built-in color names)
  • TLS - fix certificate numbering mistakes that lead to authentication failures
  • Sensors
    • New BMI270 ECMA-419 IMU driver
    • New CST816S ECMA-419 touch driver
    • New CST328 ECMA-419 touch driver
  • WebStorage – rename remove() to removeItem() for web conformance Moddable-OpenSource/pebble-examples#6
• Devices
  • ESP32
    • When USB JTAG disconnects, stop sending debug information. Eliminates periodic stalls.
    • Support high SPI clock speeds (above 20 MHz) on ESP-IDF 6
    • Avoid conflict between pins & ECMA-419 I²C. Introduced with improved error checking in ESP-IDF 6. phoddie/node-red-mcu#134 #1597
    • Add support for M5Atom Echo S3R (contributed by @stc1998)
    • Linker deadstrips unused SPI functions instead of complex conditionals #1591 (discovered by @HipsterBrown)
    • Remove all ESP-IDF v5 compatibility code (it was causing problems in some cases)
    • CPU Load displayed in xsbug again (broke with ESP-IDF 6 migration)
    • M5Atom Matrix, M5Atom S3, and M5Atom Echo migrate MPU6886 from pins/i2c to ECMA-419 I2C (contributed by @stc1988)
  • Zephyr
    • Now requires Zephyr 4.4.0 and SDK 1.0.1
    • ECMA-419 Wi-Fi module conformance improvements
  • Pebble
    • Migrate to new App lib touch support (contributed by @gmarull) #1598
    • Correct chunk/slot/stack allocation when using custom settings #1602 (reported by @cr0ybot). This makes more RAM available to Alloy apps that use custom JavaScript memory configurations.
  • ESP8266
    • Include analog in ECMA-419 manifest
    • ECMA-419 UDP handles IP address strings in flash
  • Pico
    • Fix build failures #1594 (reported by @stc1988)
    • Mods work again
• XS
  • Add unsigned integer macros to XS in C, for more correct conversions and less type casting.
  • Deprecated host buffer support removed from xsmcGetBufferReaddable() and xsmcGetBufferWritable()
• Mods
  • On microcontroller targets, module resolution was not comparing full strings causing incorrect lookups. #1603 (reported by @stc1988)
• Examples
  • Additional fixes for broader device compatibility
• Tools
  • xsdb
    • Improved thread reliability
    • Conditional breakpoints
    • eval
    • Watchpoints
    • Special case for displaying length property of arrays
  • mcconfig
    • More ESP32 build speed-ups
    • ESP32 Windows builds correctly perform ESP-IDF export if not already done
    • Allow equal signs in config values #1568 (suggested by @eliandoran)
    • Conditional import of environment variables #1446 (contributed by @HipsterBrown)
  • xsbug
    • Fix another start-up race condition
    • Fix opening of files after launch
  • mcsim
    • Fix another start-up race condition
  • mcpack
    • Accepts manifests that include a remote Git repository #1446 (contributed by @HipsterBrown)
• Documentation
  • XS in C updated with Memory Safety section about avoiding dangling pointer errors
  • Correct notes on how to use text-example (contributed by @stc1988)
  • licenses/readme.md now includes email address to send executed CLA

Contact Us

If you have questions or suggestions about anything here, please reach out:

• Start a new Discussion on our GitHub repository
• Drop by our Gitter to chat
• Contact us on X / Twitter at @moddabletech

Moddable SDK 8.0.1

This is an interim release to address priority issues for developers using ESP32, Pebble, and Node-RED MCU Edition.

Moddable SDK 8.0.0

Moddable SDK 8.0 contains improvements made between March 13, 2026 and April 13, 2026.

ESP-IDF v6

We've upgraded to the new ESP-IDF v6 from Espressif. This is a required update for ESP32 development with the Moddable SDK. Our documentation provides instructions for updating. If you forget, the build will remind you when you build for ESP32 targets.

ESP-IDF v6 is a big change – especially to the build system. We've tried to make it transparent for Moddable SDK developers. To better support the new ESP-IDF build, we now allow Moddable SDK project manifests to specify built-in IDF components to include in the build. This simplifies adding JavaScript bindings for ESP-IDF modules.

TypeScript 6

Microsoft recently announced TypeScript 6. This is a major update with some breaking changes, especially to build systems. TypeScript 6 is a stepping stone for Microsoft to a reimplemented, faster TypeScript 7. We've updated the Moddable SDK build system to work with TypeScript 6. We've gone from transpiling all TypeScript in a single invocation of tsc to invoking tsc once for each TypeScript source file. This is necessary to map source paths to the output paths as required by the Moddable SDK build. We also believe it fixes some existing (unreported) failures. It has worked reliably in our testing. However, because the change is significant, please test your projects and report any issues.

Optimized JavaScript stack

We've reduced JavaScript stack use by reworking the JavaScript stack frame used by XS for function calls. All function calls eliminate the slot that previously stored the argument count by merging it into an unused field of another slot. All ordinary function calls, basically anything except constructors invoked with new, also eliminate the slot that previously stored new.target. In addition, the changes allowed us to remove the slot used to store new.target from all arrow functions created outside a constructor.

These optimizations minimize function calling overhead, speed garbage collection, and reduce the potential for JavaScript stack overflows. Perhaps some projects can even reduce their JavaScript stack allocation. While the benefits are small on each operation, they add up. These improvements require no changes to existing code – scripts just run a bit lighter.

Touch for Alloy, Embedded JavaScript on PebbleOS

We've implemented an ECMA-419 Touch driver for Alloy, the Moddable SDK runtime for PebbleOS. Touch is available to apps using Poco by directly instantiating the driver and to apps using Piu through the familiar onTouchBegan, onTouchMoved, and onTouchEnded events. Alloy examples are available for Poco and Piu Performance is great. Moddable is excited to bring this new capability to PebbleOS and we look forward to seeing how developers use it in their Alloy projects. (Note that touch will be available to Alloy developers once integrated into a future Pebble SDK release).

xsdb

xsdb is an all-new command-line JavaScript debugger that complements xsbug, our graphical JavaScript debugger. xsdb is for embedded developers already familiar with gdb and for automated tools that need to interact with running JavaScript, from automated test harnesses to LLMs. Unlike gdb, xsdb doesn't require complicated setup. Check out our xsdb documentation to learn the fundamentals.

We'd appreciate your feedback on xsdb to help guide its development.

test-examples

The Moddable SDK contains a huge number of example projects. Ensuring that those build and run on every target device is a massive undertaking, and mistakes happen. We created test-examples to help. It performs batch builds of projects from a directory and runs each one. It uses our new xsdb debugger to validate that each example runs cleanly without any unhandled exceptions or promise rejections. While this isn't a deep API compatibility test (we have testmc for that), it does identify real issues and contribute to a smoother developer experience. You can use test-examples on your own projects too or review the code to learn how to build your own automated tools using xsdb. Our test-examples documentation will get you started.

Waveshare Touch AMOLED 2.06" Watch Development Board

We've added a port to the Waveshare Touch Watch Development board. This low-cost board contains an ESP32-S3 and runs our conversationalAI app nicely. The port includes a new CO5300 display driver, a new FT3168 touch driver, and more. It was contributed by @dashersw. Thank you!

Zephyr Tech Talk

We continue to improve our Zephyr support. This release adds runtime support for mods (user installed extensions). We hope to add support for mcrun to install mods on Zephyr.

Moddable joined a Zephyr Tech Talk this month to talk about Embedded JavaScript on Zephyr and demo some of our latest work, including mods and xsdb. Check out the fast paced dicsussion hosted by Benjamin Cabé of the Linux Foundation.

Details

The details that follow do not include the items covered above.

• Alloy – Embedded JavaScript on PebbleOS
  • Updated Piu TypeScript declarations
  • Merged changes to make instrumentation traces optional (contributed by @jplexer)
  • Draw circle works around graphics_fill_circle limitation
  • Poco bitmap fills now work with gray4 and ARGB2222 bitmaps
  • Fix HTTP requests that include a request body (Moddable-OpenSource/pebble-examples#5) (reported by @stc1988 and @vincentezw)
  • Properly sandbox keyValue storage #1590 (reported by Pebble community)
  • Report exceptions that occur when loading main rather than falling into abort handler
  • Restore lost color text fix (coredevices/pebble-tool#42)
• Modules
  • Fix linking of mod-enabled builds on microcontroller hosts
  • chatAudioIO – merge PR to expose model to applications (contributed by @stc1988)
  • DNS (contributed by @rootvector2)
    • Fix buffer overruns parsing malformed DNS packets
    • Compress names when serializing DNS packets (generates smaller, standards conformant packets)
• ECMA-419
  • File system implementations for all platforms updated to match standard
    • Unimplemented functions are omitted rather than throwing (for cleaner feature detection)
  • Zephyr builds with I2C interfaces now include SMBus class
  • Fix UUID handling in Zephyr BLE central to allow Web Bluetooth Client example to work
• XS JavaScript engine
  • Fix build failures introduced by obscure ES2026 Math.sumPrecise()
• Contributed
  • conversationalAI adapts to device screen size (previously locked to 240 x 320)
• Devices
  • Raspberry Pi Pico
    • Builds respect UF2CONV environment variable
    • Fix Wi-Fi
  • ESP32
    • Add support for ESP32-S3-Touch-AMOLED-2.06 watch development board (contributed by @dashersw)
    • Fix SPI build error (reported by @louisvangeldrop) #1581
  • Zephyr
    • Workaround for inconsistent driver interpretation of 16-bit pixels
  • Linux
    • Link ALSA drivers when using Audio In or Audio Out #1596 (contributed by @meganetaan)
• Tools
  • Rework mcrun to eliminate -f x in Pebble builds
  • serial2xsbug
    • Rework mod install to support Zephyr flash restrictions
    • -hideunrecognized option to suppress output of unexpected serial port data
  • mcsim and xsbug launch reworked to avoid crash on start when file and appearance notifications happen in unanticipated order
  • mcsim works with ECMA-419 display devices (contributed by @HipsterBrown)
  • mcconfig now supports -dl for Zephyr builds
  • strip option in manifests now fully supported on Zephyr (explicit strip list previously failed)
  • Zephyr build respects VERBOSE environment flag
• TypeScript
  • Updated declarations for correctness
  • Update Poco declarations for cleaner patching by platforms (Pebble) and modules (Outline, GIF, QR Code, etc.)
  • Add typings for mod/config (contributed by @stc1988)
  • Bumped the JavaScript version to es2025 (there is no es2026 yet in TypeScript)

Contact Us

If you have questions or suggestions about anything here, please reach out:

• Start a new Discussion on our GitHub repository
• Drop by our Gitter to chat
• Contact us on X / Twitter at @moddabletech

Moddable SDK 7.2.1

This is an interim release for Stack-chan and Pebble communities.