Moddable SDK 9.5.0

Moddable SDK 9.5 contains improvements made between August 4, 2026 and September 4, 2026.

A special thank you to @d01c2 for reporting eleven JavaScript conformance issues in a single month. And, yes, all of them are fixed in this release.

FreeType – Scalable Text

Rendering text is tough. The Moddable SDK has provided great tools to let you easily include pre-renderered anti-aliased fonts in your projects, thanks to our integration of fontbm into our build system. Through our partnership with Monotype, we've been able to offer scalable fonts using their amazing Spark renderer for commercial use. But until now, we haven't had an open-source solution for scalable fonts.

Moddable has long used FreeType to render outlines to bring SVG shapes to embedded devices. It is natural that we build on that to use FreeType to render scalable OpenType and TrueType fonts on embedded devices. This release does just that. By switching to our new FreeType font engine, both Commodetto and Piu applications can easily integrate scalable fonts. It does require more memory and code space, but many devices today can handle that, including Moddable Six. Performance is generally great, and the quality is excellent.

We've added several new examples so you can try our scalable fonts immediately.

• Text Styles. An interactive application to exercise the many text properties available using Piu.
• Pinch. Use two fingers to scale the text and one finger to drag - just like on your mobile phone.
• Text Clock. Beautifully rendered clock with multiple fonts and sizes. This uses FreeType to convert the words to outlines so they can be easily rotated and scaled.

The FreeType integration shares many of the lessons learned from the Monotype integration, including a Poco-friendly compressed font cache that both reduces the size of glyphs in the cache and allows them to render faster.

The FreeType configuration excludes the TrueType bytecode interpreter, to minimize code size. The interpreter is required for some East Asian fonts (CJK). Enable it with MODDEF_CFE_FT_HINTINGBYTECODE in your project manifest.

RFID

Hardware to support RFID (Radio-Frequency Identification, aka Near-Field communication) has been increasingly common. We're introducing an RFID API based on the ECMA-419 Sensor Class Pattern. It supports common NFC operations including detecting when a tag is present, reading and writing blocks, and using the NDEF format (NFC Data Exchange Format). We've implemented this for the MFRC522/WS1850S, PN532, and ST25R3916 RFID chips. There are new examples to get you started - detecting RFID presence and logging that to the console or display, and writing using NDEF. Check out the readme to get started.

The M5Dial includes the MFRC522, so we've updated its host instance provider so you can instantiate the RFID sensor through new device.sensor.RFID().

WebDAV – Every Device is a File Server

Wouldn't it be great if you could easily copy between your computer and your embedded device? With our new WebDAV module, you can. WebDAV is a file server protocol, standardized in RFC 4918, with client support on macOS, Windows, and Linux. That means you can mount your embedded device as a file server from your computer and use the GUI or command line to move files back and forth.

The macOS Finder integration of WebDAV is very chatty, which slows things down. If you have lots of transfers to do, we like Transmit 5 from Panic as a GUI, or you can use the command line.

Our new WebDAV implementation is actually not that new. It is an update of unpublished work from nearly a decade ago by Mark Wharton.

XML - Parse and Serialize

XML? In 2026?!? Yes. XML never went away, even if JSON does rule the world. One use of XML is the WebDAV protocol (another is our xsbug protocol!). We've integrated an XML parser and serializer in this release, and it is used extensively by the WebDAV implementation. Both the parser and serializer are carefully optimized for embedded use, taking great care to minimize memory use and work with data efficiently. Many thanks to Mark Wharton for his meticulous work. When your project needs to handle XML, there's now a reliable solution built into the Moddable SDK.

HTTP Server - Keep-alive and Hardening

Our ECMA-419 HTTP Server implementation has received a lot of attention in this release. Much of that was motivated by the WebDAV integration, as WebDAV is an extension to the HTTP Server. Requests are handled faster and more reliably.

• Keep-alive now supported. With keep-alive support, the HTTP Server can respond to several requests over a single TCP connection. This eliminates the overhead of creating a TCP connection for each request, overhead that is substantial, particularly when the requests themselves are small.
• onRoute callback. The routing of incoming requests has been significantly streamlined with the new onRoute() callback. Our HTTP Server Guide explains how to use it.
• Hardening. The underlying TCP and Listener sockets had race conditions on platforms using lwip (ESP32, Raspberry Pi Pico). These led to stalls, subtle failures, and crashes. These have been resolved.
• Optimization. HTTP request header parsing has been rewritten to eliminate the garbage collector thrashing of the original versions.

ECMA-419 Migration Continues

Our mission to have the Moddable SDK fully based on ECMA-419 continues to make progress. This release migrates the Button, LED, and Backlight classes from the original pins API to ECMA-419. This required updates to dozens of device build targets. We've done this work to be backwards compatible as well, but it is a lot of changes to test.

To help with your migration to ECMA-419, we've added warnings to the build when the project includes the manifest of a module that has an ECMA-419 alternative available. The migration warnings appear at the very start of the build. Please check your projects. There's still more work to do in the Moddable SDK to complete the migration. Your PRs to assist, especially in the device targets, are very much appreciated.

Guides – More Docs for Developers and their LLMs

Our new Guides, introduced in August, are the documentation you've always wanted: code-first, concise, and clear, filled with practical examples of common tasks faced by Embedded JavaScript developers. This month adds several new guides:

• HTTP Server. Every project seems to reach a point where it needs an HTTP server. Adding that can be intimidating. It is actually pretty easy. Our guide shows how to create a server, serve web pages, upload and download files, and more.
• WebSocket Server: The WebSocket protocol is usually the most efficient way to have bidirectional conversations between an embedded device and a remote. This is especially true when communicating with a web browser. Adding a WebSocket Server to your project is easy – it builds on the HTTP Server.
• Captive Portal. Configuring Wi-Fi is one of the most challenging aspects of many real Embedded JavaScript projects. Often developers resort to building custom mobile apps for this. Our captive portal module lets users configure Wi-Fi using their phone's browser: no mobile app is required. You can even use the captive portal to configure other device settings like date and time, time zone, daylight savings time offset, and the user's preferred language.
• How Time and Timezone are Initialized. Demystifies how time and timezone are initialzed when debugging and what you need to do in your project to initialize them when not debugging.

In addition to the new guides, there are many updates to the existing guides based on experience using them.

ESP-IDF v6.1

We've upgraded to the latest ESP-IDF v6.1 from Espressif. You probably yawn and stop reading when you hear "IDF update." We do them often, so you can stay up-to-date with the latest fixes, optimizations, and security fixes from Espressif. This update has a very real benefit for Embedded JavaScript developers: differential flashing (aka "fast reflashing").

What's differential flashing? The i...

Moddable SDK 9.0.0

Moddable SDK 9.0 contains improvements made between July 3, 2026 and August 4, 2026.

Moddable SDK 9.0 is a huge release with features that have been in the works for a long time. Its powerful new capabilities empower Embedded JavaScript developers to do more, more easily, in more familiar ways, with less code. Our new documentation suite guides developers (and their LLMs) to make the best use of the capabilities the Moddable SDK provides.

This release also contains several conformance improvements and patches a few security vulnerabilities. Many thanks to the individuals who contributed their expertise and time to ensure the robustness of the Moddable SDK for all Embedded JavaScript developers.

Streams – Squeezing One More Web Foundation into Embedded Devices

Streams are a foundation feature of modern Web APIs. Until now, they haven't been available to Embedded JavaScript developers. Moddable has created a completely new implementation of the Web platform's Streams API tightly optimized for use with our XS JavaScript engine. It delivers excellent compatibility with Streams in web browsers, with a relatively light code size and memory footprint.

The Streams API is a powerful tool to build data flows by connecting together different kinds of streams. The Streams API takes care of moving data through the flows with mechanisms for managing buffering to keep memory use under control. The Moddable SDK supports advanced features of the Streams API, including pipes, transforms, tees, and bring-your-own-buffer. Streams are built around promises, so they are fully asynchronous.

By themselves, the core Streams API classes are powerful. But the Web platform uses them as a building block for many high-level Web APIs. Several of those have also landed in the Moddable SDK.

• fetch() uses streams to stream request bodies and response bodies. Internally, fetch() uses DecompressionStream to transparently decompress compressed HTTP responses.
• Web Serial uses a readable and writable stream to access ECMA-419 Serial ports
• WebSocketStream uses a readable and write stream to access WebSocket messages.

In addition, Streams can be used with ECMA-419 Embedded IO to move data around and apply transforms. The Moddable SDK contains examples that show streams attaching a button to an LED and using WebSocketStreams to transmit touch sensor samples from one embedded device to another.

We're very excited about the ability of streams to further simplify Embedded JavaScript development by providing another bridge between the modern Web platform and Embedded JavaScript.

Guides – A New Kind of Docs for Developers and their LLMs

Documentation is one of the most contentious topics in software development. Our new Guides are a new kind of documentation. They take a code-first approach to explaining the Moddable SDK. They are an extensive collection of small code snippets paired with brief text explanations. They show how to perform common tasks simply. Guides provide a path through essential APIs to get developers started quickly. They complement reference documentation and standards.

In many cases, there are two (or three!) different APIs available to perform the same task such as making an HTTP request. The guides describe all of them and give guidance on choosing the right one for your project.

The Guides are also designed to be friendly for LLMs. The consist of small chunks of knowledge that combine code written using best practices along with concise, relevant details. We've had great results pointing various coding agents at the guides to aid them in reviewing and writing Embedded JavaScript code for the Moddable SDK.

Each Guide, like HTTP, Optimizing, and Time, begins with an Overview page that links to all its articles. The overview brings together essential knowledge including build instructions for developers using mcconfig or mcpack, along with links to reference documentation, TypeScript declarations, examples, implementations, and relevant standards – everything you and your LLM need to fully understand the topic.

There are nearly 150 (!!) articles in this first release of the Guides. There's more to do. We'd love to hear from you about what's there now, and what you'd like to see next.

Captive Portal

One of the greatest headaches for an Embedded Developer is providing a way for users to configure the Wi-Fi on an embedded product. We've added a Captive Portal module that manages this process from start to finish. It creates a Wi-Fi Access Point that the user can connect to from their phone without the need to install a mobile app. This module weaves together many different modules built around ECMA-419, including Wi-Fi Access Point, Wi-Fi client, HTTP server, WebSocket server, and a DNS Server.

We look forward to hearing from developers about how they've used the new Captive Portal in their projects, and their ideas for how the API can be extended to cover additional scenarios.

Stack-chan 1.0

Stack-chan has been one of our favorite open source communities since it won the Hackaday Prize silver medal in 2021. Since then, the community has grown continuously, but the vision of a friendly desktop robot that anyone can easily make their own using standard JavaScript has never wavered. The project has pushed the Moddable SDK forward through its innovative use of embedded technologies with the goal of always making a better experience for users and developers. They recently used the WASM support in the Moddable SDK to build a Stack-chan web simulator – a huge achievement.

Along the way, the official Stack-chan firmware reached version 1.0. Check out the latest on the official Stack-chan GitHub repository. Congratulations to @meganetaaan, @stc1988, and the many other contributors to Stack-chan!

ESP-IDF v6.0.2

We've upgraded to the latest ESP-IDF v6.0.2 from Espressif. This is an incremental update, as we are already on ESP-IDF v6.0. Among many improvements, ESP-IDF v6.0.2 fixes a bug with BLE peripheral names that impacted developers using the Moddable SDK.

Instructions for updating are in our documentation. If you forget to update, the build will remind you.

TypeScript 7

We've confirmed that the Moddable SDK is compatible with TypeScript 7. By all reports, TypeScript 7 is significantly faster than previous versions. We recommend migrating to TypeScript 7 as soon as practical. Building with TypeScript 6 still works. Congratulations to the TypeScript team on this major achievement.

Details

• Modules
  • All new implementation of Web platform streams. Details above.
  • All new AbortController and AbortSignal implementations, primarily for use by Streams
  • All new DOMException module, primarily for use by Streams
  • All new Captive Portal module for provisioning Wi-Fi without a mobile app. Check out the example
  • All new DNS Server written using ECMA-419 UDP. Primarily useful for redirecting in a captive portal.
  • All new Web Serial module that combines Streams with ECMA-419 Serial to provide support for the popular Web Serial API on embedded hardware.
  • All new WebSocketStream() module that implements the experimental Web platform class that applies Streams to the WebSocket protocol to simplify and improve on the classic WebSocket().
  • New stream-enabled [fetch() module](https://github.com/Moddable-OpenSource/moddable/blob/public/examples/web/stre...

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.