Moddable SDK 7.1 contains improvements made between January 14, 2026 and February 11, 2026.

Our January release was a big one and a little later than usual. We're happy for the dust to settle in our February release. Still, there are two big items in this release.

ES2026 – the very latest JavaScript

The annual update to the official JavaScript language standard is expected in June, but our XS JavaScript engine already implements all the features expected to be part of that. XS passes 100% of the test262 tests for all new features, so you'll see consistent results running on a $1 microcontroller or in a web browser on a $1000 computer. For complete details, check out XS Conformance.

Here's a summary of the new features in ES2026 with notes on what they mean for Embedded JavaScript developers.

• Upsert – This curiously named proposal is a Map and WeakMap optimization. A common pattern is to use has to check if an item exists, and then either add it with set or retrieve it with get. The new insertOrGet() method does all that in one step, eliminating code, function calls, and some internal calculations. The MDN documentation provides several examples. The insertOrGetComputed() variation is for when creating the default value is relatively expensive. If your Embedded JavaScript project makes heavy use of Map (possible) or WeakMap (unlikely), give these new calls a look. They could save you some cycles.
• JSON.parse() source text access – The source text used to generate JSON values is now available to scripts through a new parameter to the reviver callback function. This can be used to provide higher precision than JSON.parse supports, for example to use BigInt values for large integer values.
• Iterator Sequencing – This addition to the Iterator Helpers provides Iterator.concat() to easily sequence two or more iterators as a single iterator.
• Uint8Array to/from Base64 – This adds Base64 and Hex conversion functions to Uint8Array. Hex conversion is convenient for debugging Embedded JavaScript binary data – trace(Uint8Array.of(1, 2, 3, 4).toHex(), "\n"); The Moddable SDK has supported this proposal for a couple years now, and all modules and examples have transitioned to use it.
• Math.sumPrecise() – When adding more than two floating-point values, a more precise result is obtained by a specialized algorithm. This can also avoid some unexpected results, as MDN explains. This capability is unlikely to be essential for embedded developers as most values don't require such high precision.
• Error.isError() – This new function tests whether an object is descended from Error. This is primarily useful with realms, which are not used by embedded developers.
• Array.fromAsync() – This convenience function creates a new array from an asynchronous iterable object. See MDN for details.

XS also implements Explicit Resource Management, a Stage 3 Proposal that improves resource management. This proposal is relevant for Embedded JavaScript developers working in resource-constrained environments. The feature is disabled in XS by default, but can be enabled by setting mxExplicitResourceManagement.

Embedded JavaScript developers know that one of the constrained resources they have to manage is the flash memory space that stores code – their code, the RTOS, and the Moddable SDK. There's a reasonable concern that these new language features will require space in flash memory, which will eventually cause it to overflow with unused features. Fortunately, the Moddable SDK has you covered. By default, Moddable SDK builds automatically strip unused features from the JavaScript engine. The code for those features is never installed on the device. Even ChatGPT understands this, although it gets some of the details wrong, so better to read our docs.

Over the last year, test262 has evolved to be even more precise. See XS Conformance for the latest test results in detail.

Zephyr Builds on Windows

You can now build Zephyr projects on Windows. The set-up is straightforward:

1. Install Moddable SDK
2. Install Zephyr SDK and tools
3. Build your project using mcconfig as normal

Step-by-step instructions are included in our updated Zephyr documentation.

Many Moddable SDK developers already have an ESP32 board (or three). You can use Zephyr on most ESP32 family boards – including Wi-Fi, BLE central, and displays. That's an easy way to start exploring. We've had good luck with boards from ST, such as the Nucleo F413ZH.

xs-dev for Zephyr

Many Embedded JavaScript developers use xs-dev to install and update the Moddable SDK and the embedded SDKs that it depends on. The most recent release of xs-dev adds support for Zephyr on macOS and Linux. Using xs-dev is the easiest way to install everything you need to work with the Moddable SDK. Thanks to Nick Hehr for the ongoing support!

Details

These notes do not include features described above.

• Modules
  • chatAudioIO – Update default queueLength to prevent stalls with certain LLM engines. (Contributed by @stc1988)
• XS JavaScript engine
  • Optimize double to integer conversion for common values. Uses ilogb() to bypass unnecessary double precision calculations while maintaining ECMA-262 conformance.
  • Fix obscure stack overflows in Array flatMap and sort functions. These caused operations to fail that should have succeeded.
  • Fix signature of fxBoolean() to be consistent everywhere.
  • Fix incorrect serialization in escape() and enable optimization when no escaping occurs. #1562 (Reported by @ChALkeR)
  • Fix incorrect serialization of empty objects and empty strings with padding by JSON.stringify(). #1564 (Reported by @ChALkeR)
• TypeScript
  • Rename BufferLike to ByteBuffer to match ECMA-419 terminology. This is potentially a breaking change to existing TypeScript code.
• Documentation
  • Update Zephyr docs with flash, files, and key-value notes.

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.0 contains improvements made between December 4, 2025 and January 13, 2026.

Zephyr Port Now Official

We began porting the Moddable SDK to the Zephyr RTOS in 2025, with the first public preview in October. In the few months since then, the Zephyr port is sufficiently capable and complete that we are promoting it to an officially supported platform of the Moddable SDK. This means future Zephyr updates will be delivered as part of our regular monthly release.

To understand the breadth and depth of our Zephyr port, check out our blog posts that detail our progress:

• Modern JavaScript for Zephyr
• Moddable SDK on Zephyr RTOS Advancing Quickly with Networking, BLE, and More Storage
• Displays, Ethernet, and More Boards Land in Zephyr Port

Our comprehensive Zephyr documentation covers getting set up, building, debugging, and how we bridge Zephyr's foundational Device Tree to JavaScript.

In the last month, we've done a tremendous amount of work to refine the Zephyr port, including the addition of Analog Input and PWM IO, and making it easier to begin working with new development boards from any silicon provider.

We're excited to have Zephyr fully onboard in the Moddable SDK and look forward to continuing to deepen our support for this popular, well-supported platform.

ESLint and TypeScript Checks Integrated with Build

ESLint and TypeScript are valuable tools for checking the correctness of JavaScript and TypeScript source code before it is parsed, compiled, and run. These checks save Embedded JavaScript developers valuable time by identifying mistakes before code is downloaded to the target device. Moddable SDK 7.0 makes running these checks much easier.

When building with mcconfig or mcrun you can now check your JavaScript and TypeScript source code with ESLint and/or TypeScript. All you have to do is add -tc to your command line for TypeScript checks and -lc for ESLint checks. You can check both in a single build:

mcconfig -d -m -p zephyr/esp32_ethernet_kit -tc -lc

You do need to have TypeScript and ESLint installed. Fortunately installing them is straightforward, but be sure to install them globally.

npm install -g typescript
npm install -g eslint

Because the ESLint and TypeScript checks don't usually increase build time significantly, you can consider keeping one, or both, enabled during active development.

When using TypeScript to check JavaScript source code, the checks are less strict because there is less type information available. Still, the TypeScript checks are valuable.

The TypeScript checks depend on the available type declarations, primarily in $MODDABLE/typings. These are increasingly complete, but not entirely. Where they are incomplete, there can be failures. This happens with access to the device global, though Zephyr builds handle this well thanks to mcdevicetree. Being able to build all Moddable SDK examples with TypeScript and ESLint checks enabled is a goal, which should resolve the majority of these issues.

The checks are performed on the source code of your project. They are not performed on code included by your project from the $MODDABLE/modules and $MODDABLE/build directories. Checking this code is more challenging because it implements the system and so may not always conform with the publc APIs. Extending checks to the code in these directories is an area for future work.

Release Details

• Devices
  • Zephyr
    • Implement ECMA-419 analog input
    • Implement ECMA-419 PWM output
    • RTC module migrated to New Native API
    • Wi-Fi and Ethernet modules provide MAC property
    • Complete implementation of timezone and daylight savings offsets
  • M5Stack CoreS3
    • Support microphone #1552 (contributed by @meganetaaan)
  • ESP32
    • ECMA-419 Audio Out should use ISR calls from playedBuffer callback (contributed by @meganetaaan)
    • Fix missing debugger_uart_cdc.c on Windows builds #1555 (reported by @rillhu)
    • Replace deprecated VSPI_HOST with SPI3_HOST #1556 (reported by @NW_LAB)
• conversationalAI
  • Enable model selection user interface by default
  • Add models for Gemini and OpenAI (contributed by @stc1988)
  • Migrate to New Native API
• Modules
  • chatAudioIO
    • Update tools support to latest across supported services
    • Migrate to New Native API
  • WebSocket – don't trip over omitted callbacks (onerror, etc)
  • CRC - migrate to New Native API
  • ResourceIterator - migrate to New Native API
  • TLS – remove Hex module; replaced by JavaScript's Uint8Array Hex support
• ECMA-419
  • DNS-SD changes instanceName to name
  • BLE security options name changes for display and keyboard capabilities
  • MQTT client merges its configuration into Host Instance Provider rather than overwriting
• XS JavaScript engine
  • Fixed range of Math.random() on ESP32 and ESP8266. #1544 (reported by @stc1988)
  • Fuzzing fixes
    • JavaScript parsing crash introduced with New Native API
    • Obscure string buffer overflow converting BigInt to string
    • Native stack overflow when parsing JSX
• Tools
  • test262 app migrated to New Native API
  • Fix ESP32-C6 builds that include BLE
  • mcdevicetree
    • Use Zephyr CONFIG_* value to enable features
    • Uses "compatible" DTS field to determine node type across different silicon vendors
    • Fix capitalization on port names (e.g. device.serial) to match ECMA-419
    • Includes display, RTC, and DigitalBank in device global
  • mcconfig
    • Supports Zephyr overlays in manifests
    • Escape # in Zephyr filenames (necessary for Node private modules)
    • TypeScript now supported on Zephyr
    • ESLint checks JavaScript and TypeScript source code (-lc on command line)
    • TypeScript checks JavaScript source code (-tc on command line)
  • testmc
    • Option to override screen size because many graphics tests assume a 240 x 320 display
    • Checksum display driver compatible with ECMA-419 Display driver
• TypeScript
  • Add typings
    • ECMA-419 Ethernet and Wi-Fi
    • ECMA-419 Display
    • ECMA-419 NTP Client
    • ECMA-419 Real-Time Clock
    • ECMA-419 Files
    • ECMA-419 Key-Value Pair Storage
    • ECMA-419 Flash
    • ECMA-419 BLE Peripheral (contributed by @stc1988) #1558
    • Neopixel and Neostrand (contributed by @stc1988)
  • Correct deflate.ts file name to deflate.d.ts
• Documentation
  • Integrate Zephyr
  • Update Windows set-up to latest Visual Studio #1557 (contributed by @NW-Lab)
• Examples
  • Fixes some issues reported by ESLint

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 6.1 contains improvements made between November 8, 2025 and December 4, 2025.

conversationalAI Upgrade

conversationalAI is a complete interactive chat application implemented in Embedded JavaScript. This release includes a major upgrade to the app to bring new features and keep pace with the rapidly evolving AI APIs. conversationalAI is a complete demonstration of our chatAudioAPI, which provides a uniform API for working with popular AI services. Use chatAudioAPI to build your own interactive chat application.

conversationalAI now lets you select the model to use. To support that and better handle voice selection, the chatAudioIO API has been updated. Check out the chatAudioIO documentation for details.

This release improves support for every AI service:

• Google Gemini Live
  • Upgraded to Gemini 2.5 Flash Live
  • Input and output transcription supported
• OpenAI Realtime
  • Implementation migrated from beta to GA
• Deepgram Agent
  • Listening model upgraded to Flux
  • Default language model is Anthropic Claude Haiku 4.5
  • Select provider and model by identifier
• ElevenLabs Agent
  • Voice identifiers and descriptions are fetched separately
  • Default language model is Anthropic Claude Haiku 4.5
  • Select provider and model by identifier
• Hume AI EVI
  • Implementation migrated to EVI version 4-mini
  • Voice identifiers and descriptions are fetched separately.
  • Default language model is Anthropic Claude Haiku 4.5
  • Select provider and model by identifier

We've made Anthropic Claude Haiku 4.5 the default service where possible. We think it delivers the right tradeoffs for conversational AI. Of course, you can switch to any model you like!

We've also updated the audio level meter feedback when the user speaks. We've switched to a logarithmic scale for more responsive feedback and more consistent results across devices.

Thank you to @stc1988 for feedback and prototyping that contributed to this upgrade.

Moddable Six Upgrade

Moddable Six, our most powerful development board, has been upgraded with the addition of a microphone. We also completely redesigned the audio amplifier to deliver louder sound and better audio quality. We did all of that while keeping the price the same – starting at just $29.99. If you are looking for no-hassle hardware to start exploring Embedded JavaScript, Moddable Six is a great choice.

• ESP32-S3 with dual-core 240 MHz CPUs
• 8.5 MB RAM
• 8 MB flash storage
• Wi-Fi
• BLE
• High-speed QVGA display
• Touch screen
• Speaker
• Microphone
• Serial & USB ports for programming and debugging
• Qwiic/Stemma QT I²C connector

We also simplified the build for Moddable Six. You now use the esp32/moddable_six platform for both USB and serial connections. The esp32/moddable_six_cdc platform has been retired.

Ethernet Upgrade

Ethernet is a great alternative to Wi-Fi. It is fast, reliable, and secure. We've supported Ethernet on the ESP32 family for years. The Case for Ethernet introduces the support.

This release includes changes contributed by @rmontrosecbw to improve our Ethernet support:

• Updates implementation to the latest ESP-IDF APIs
• Integrates with ESP32-S3
• Support for the Wiznet W5500 Ethernet interface
• More configuration options for internal Ethernet as found on the WT-ETH01
• Static IP addresses in addition to the existing dynamic addresses with DHCP

In addition, we now support the Espressif Ethernet Kit development board.

Zephyr RTOS Port Upgrade

We launched our Zephyr RTOS port in September. In October, we enabled a pile of new capabilities including Wi-Fi, BLE, and storage. November has been just as productive. For more details, see Displays, Ethernet, and More Boards Land in Zephyr Port.

• Display support is now in place. This includes the low-level JavaScript display driver and integration with our Poco renderer and Piu user interface framework. Performance is outstanding. Check out this video.
• Ethernet networking has been enabled. This works just as transparently as Wi-Fi.
• Testing support is in place with both test262 and testmc running. This allows us to begin in-depth testing of JavaScript and the Moddable SDK on Zephyr.
• Fixes to issues found by test262 including sorting, binary search (used by RegExp), and access to BigInt64 values in DataView.

Grab the latest from our Zephyr branch. Getting started is straightforward thanks to the Zephyr SDK's smooth set-up.

Release Details

These notes do not include the features described above.

• Devices
  • Correct range of Math.random() and Math.irandom() on ESP32 and ES8266 #1544 (reported by @stc1988)
  • Fix Windows build of BLE for ESP32-C6 #1545 (reported by @louisvangeldrop)
• ECMA-419
  • Audio output buffering changes on ESP32 to avoid triggering ESP-IDF timeout
  • Name changes in DNS-SD to follow committee decisions
  • Name changes in BLE to match committee decisions
• XS
  • Fix parsing error introduced by native constructor #1543 (found by oss-fuzz, also reported by @gal1ium)
  • Fix string overflow in BigInt to string (found by Fuzzilli)
• Examples
  • Remove TypeScript fragment from piu/list example so it builds correctly again

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 6.0 contains improvements made between October 2, 2025 and November 7, 2025.

New Native API

We've added a new way to bind native C functions to JavaScript. Unlike its predecessor, the new Native API uses 100% standard JavaScript, making it friendly for tools in the JavaScript ecosystem, including TypeScript, ESLint, and LLM-based AI agents. The intent of the code is now more clear to humans as well.

We're excited about this change and have already updated a significant portion of the Moddable SDK to use it. To learn about the benefits and motivation, read our blog post. For technical details, check out the latest XS in C documentation.

Piu Memory Optimization

We've made an optimization to our Piu user interface framework that saves 28 bytes per object on microcontrollers. For a product with dozens or even hundreds of objects, the savings are significant.

What did we change? A powerful feature of Piu is that every UI object can be a timer. This simplifies the code because many behaviors in a UI require a timer. Prior to this optimization, each Piu object reserved storage for the timer. With the optimization in place, Piu now only allocates memory for the timer for objects that need it.

No changes are necessary to your code to benefit from this optimization. If you've written any native extensions to Piu, their initialization will require a small update to work properly.

As part of the timer changes, we've also reduced the memory used by the name property of objects. While name isn't widely used, every byte matters.

ESLint Support

Linters are a valuable tool for detecting common mistakes in code. ESLint is one of the best linters for JavaScript. With our new Native API, it is possible to run ESLint against the majority of the JavaScript code in the Moddable SDK.

The default configuration of ESLint is designed for web developers. Embedded JavaScript developers have somewhat different needs. We've run ESLint against many modules and examples in the Moddable to create an ESLint configuration that is well-suited for Embedded JavaScript.

After installing ESLint, you can lint the contents of any directory in the Moddable SDK.

cd $MODDABLE/examples/helloworld
eslint

We used ESLint to detect a healthy collection of minor issues in our examples and modules. Corrections for all those have been included in this release.

TypeScript Refresh

This release includes a major refresh of our TypeScript declarations for the modules in the Moddable SDK. We've updated to the latest TypeScript features and conventions, updated APIs, and corrected mistakes. There are significant improvements to type declarations for Piu.

We've also added new TypeScript declarations for many modules:

• ResourceIterator
• Commodetto static extension
• Commodetto colorcell extension
• commodetto/loadJPEG
• commodetto/ReadGIF
• commodetto/readStream
• commodetto/BufferOut
• commodetto/Convert
• commodetto/ReadPNG
• piu/QRCode
• deflate
• inflate

There are also TypeScript declarations for the native() and Native() global functions in our new Native API.

At this point, just about all of the Piu and Commodetto examples can run under TypeScript with minimal changes to accommodate TypeScript. That was not the case before.

Our TypeScript declarations are valuable for developers and for AI agents. We will continue to improve them for the benefit of both.

The Moddable SDK typings are included in our repository. They are also available as an NPM package to install in your project:

npm install @moddable/typings

As a quick reminder, working with TypeScript in the Moddable SDK is a simple two-step process.

1. Install TypeScript

2. Include $MODDABLE/examples/manifest_typings.json in your project's manifest.json.

   	"include": [
   		"$(MODDABLE)/examples/manifest_base.json",
   		"$(MODDABLE)/examples/manifest_typings.json"
   	]

Zephyr RTOS Port Advances

Since the launch of our Zephyr RTOS port last month, we've been working hard to port more features. We've updated our Zephyr branch as part of this release. This is what you'll find there:

• Wi-Fi
• Network sockets – UDP, TCP, Listener
• File System
• BLE Client
• Real-Time Clock
• NTP Client (network time)
• Espressif ESP32 support
• Bug fixes

Wi-Fi and NTP are the first implementations we've done of these APIs from the ECMA‑419 Standard. We'll bring these to other platforms in the future.

What's particularly great is that once we bring up the portability layer, our JavaScript libraries run unchanged. For example, now that network sockets are available, we've verified that our DNS Client, HTTP Client, HTTP Server, and MQTT Client all work on Zephyr.

For all the details, check out our article "Moddable SDK on Zephyr RTOS Advancing Quickly with Networking, BLE, and More Storage".

Release Details

Note that these notes do not include the features already described above.

• Tools
  • ESP32 installation reliability improvements on Linux (reported by @mshioji)
• Modules
  • Worker
    • Option to set thread priority and CPU core affinity on FreeRTOS targets (ESP32). Contributed by @rmontrose.
• ECMA-419
  • mDNS renamed to DNSSD
  • Fetch fix when no headers to send
• XS
  • Linker's strip now eliminates Proxy getter and setter when Proxy is unused
• Devices
  • ESP32 devices using TinyUSB for debugging again build and run #1542
• Examples
  • New example shows using subclass work with Worker Contributed by @rmontrose.
  • Replace global with preferred globalThis
• Documentation
  • Add xsReference and xsToReference to XS in C
  • Document new Native API in XS in C
  • Correct Piu easing equation argument documentation

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 5.12.0 contains improvements made between September 11, 2025 and October 2, 2025

Zephyr RTOS Port Preview

Zephyr is an open source RTOS project hosted by the Linux Foundation. We like its lightweight runtime and rigorous design. Zephyr runs on hundreds of development boards across many major silicon families.

Moddable has begun porting the Moddable SDK to Zephyr. The initial focus is on silicon from STMicroelectronics. ST has an impressively broad portfolio of embedded microcontrollers with strong IO capabilities. ST silicon support is a common request. We're excited to publish a branch of the Moddable SDK with our Zephyr port in progress.

Our Zephyr blog post has all the details. We're looking for contributors to try out the port, track down bugs, help implement modules, and try it out on more silicon.

New ECMA-419 DNS-SD Preview

DNS-SD is a network protocol for devices to discover each other on the local network. It is widely used on computers, phones, and consumer electronic products. It is formally defined in RFC 6763 The Moddable SDK has long supported these protocols. More recently Ecma TC53 has proposed a standard API for DNS-SD that builds on the class patterns for embedded devices in ECMA-419. The ECMA-419 API is simpler to use, more flexible, and more powerful.

This release of the Moddable SDK contains the first implementation of the ECMA-419 DNS-SD API. The committee's work is not yet complete, so changes are possible. Please consider this a preview.

To work with DNS-SD, first create an instance of the service:

const dnssd = new (device.network.mdns.io)(device.network.mdns);

Use that instance to claim a name on the local network:

const claim = dnssd.claim({
	host: "example-server",
	onReady() {
		trace(`"example-server" claimed\n`);
	}
});

Once the name is claimed, you're ready to advertise services on the local network:

dnssd.advertise({
	serviceType: "_http._tcp",
	instanceName: "419 Web Server",
	host: "example-server",
	port: 8080
});

Discovering DNS-SD services on the local network is just as easy:

dnssd.discover({
	serviceType: "_http._tcp",
	onFound(service) {
		trace(`Found: "${service.name}" on ${service.host} @ ${service.address}:${service.port}\n`);
	},
	onUpdate(service) {
		trace(`Update: ${service.name}\n`);
	},
	onLost(service) {
		trace(`Lost: ${service.name}\n`);
	}
});

The API supports making multiple claims, advertising multiple services, and discovering multiple kinds of services.

We've got an all-new example that shows how to use all these features in more detail. The example works best on ESP32 and has also been tested on macOS. We've also added TypeScript type declarations.

Give it a try and let us know how it goes.

macOS Tahoe 26

We've verified that the Moddable SDK is compatible with the latest release of macOS. We've updated the icons of our xsbug and mcsim applications for the new OS.

ESP-IDF v5.5.1

The Moddable SDK has migrated to ESP-IDF v5.5.1 for all ESP32 family builds. The release contains improvements from Espressif, particularly BLE. As usual, no code changes are required for the vast majority of projects using the Moddable SDK. Updating takes just a few minutes:

• If you use xs-dev to install the Moddable SDK, execute xs-dev update --device esp32
• Otherwise, follow the update instructions for macOS and Linux, or Windows.

Release Details

• ECMA-419
  • New mDNS / DNS-SD service added
  • New BLE Client and Server updated to reflect latest TC53 recommendations
  • Update MCP23017 expander manifest and example (contributed by @stc1988)
• Contributed
  • conversationalAI fix for typo in default voice. (contributed by @stc1988)
• Examples
  • New ECMA-419 mDNS / DNS-SD example showing initialization, local name claiming, service advertising, and service discovery.
• Documentation
  • XS in C updated to include xsCallFunction* macros (requested by @rmontrosecbw)
• Tools
  • mcconfig and mcrun import of git repositories uses default manifest of manifest.json as documented (reported by @stc1988) #1532
• Modules
  • DNS serializer now also accepts a Map instance for txt record
  • Fix path for mbedtls on Windows for latest ESP-IDF (contributed by @rmontrose)
• XS JavaScript engine
  • Linker no longer truncates strings longer than 64 KB
• TypeScript
  • ECMA-419 mDNS / DNS-SD typings added
  • ECMA-419 BLE Client and Server typings updated

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 5.11.0 contains improvements made between August 12, 2025 and September 11, 2025.

New ECMA-419 BLE Server

This release contains a completely new API for implementing Bluetooth Peripherals (also called BLE Servers). Our original Peripheral has worked well for many years, but has some shortcomings that we wanted to address. Moddable has proposed this API to Ecma TC53 to become part of the ECMA-419 standard.

The server API is mostly about describing the BLE services, characteristics, and descriptors that make up the device. Rather than a long list of APIs to call to define all those, a single JavaScript object fully describes the hierarchy of services, characteristics, and descriptors within a device. This results in extremely direct, readable code that makes creating and maintaining a BLE Peripheral much easier. Check out our heart-rate monitor server example to see how it works.

The server is implemented for both ESP32 using the NimBLE stack and macOS using Core Bluetooth. This is the first time we've supported Bluetooth server in the simulator. This has proven to be incredibly powerful for accelerating Bluetooth development, even with the limitations of Core Bluetooth.

The new BLE Server is still experimental, so you can expect changes. But it is working very nicely, so we wanted to share it now to get experience and feedback while it is still evolving.

New ECMA-419 BLE Client, secured

This release contains numerous improvements to our new BLE Client, most notably a first draft of support for security including pairing and bonding. The new health temperature example shows how easy it is to add security settings to your BLE client. Learn about our new BLE Client in July's release notes.

ESP-IDF v5.5.1

The Moddable SDK has migrated to ESP-IDF v5.5.1 for all ESP32 family builds. The release contains improvements from Espressif, particularly BLE. As usual, there should be no code changes required for the vast majority of projects using the Moddable SDK. Updating takes just a few minutes:

• If you used xs-dev to install the Moddable SDK, execute xs-dev update --device esp32
• Otherwise, follow the update instructions for macOS and Linux, or Windows.

Note: Updating to the latest ESP-IDF using xs-dev is now more reliable. xs-dev now automatically determines the ESP-IDF version required by the Moddable SDK, so there's no need to update xs-dev to have it use the recommended ESP-IDF version. Of course you will need to update xs-dev to get these improvements ;) Thank you to @stc1988 and @HipsterBrown for their contributions to this improvement.

Release Details

• ECMA-419
  • BLE Client
    • 128-bit UUID strings correctly formatted
    • Improve error reporting and out-of-memory handling
    • enableNotifications divided into subscribe and unsubscribe
    • filters removed from the constructor options object and its services property is now at the root of the constructor options object
    • Added new example showing how to use ECMA-419 GAPClient for BLE discovery and then handoff to Web Bluetooth for GATT operations. This provides developers full flexibility on discovery, something that is expressly prohibited by Web Bluetooth.
    • Implemented experimental security support – pairing and bonding. See secure health temperature example.
  • HTTP Client
    • Eliminate cascade of unnecessary floating-point operations when no content-length given on unchunked response
• Modules
  • Piu
    • Save 8 bytes of memory on each Piu Content instance by optimizing data structures
  • Bluetooth / BLE – more comprehensive workaround for ESP-IDF bug where notifications are not delivered to client unless ESP-IDF BLE server code included in build
  • Eliminate unnecessary floating-point operations in MP3 decoder
• Devices
  • M5StackCoreS3 now uses ECMA-419 touch sensor driver (contributed by @stc1988)
  • Ethernet support on ESP32 devices enhanced to support WizNET W5500 and use code from ESP Component Registry. (contributed by @rmontrosecbw)
  • c_rand() on ESP32 and ESP8266 now returns non-negative signed values to match rand() (previously could generate negative values which broke some native code)
• Examples
  • ethernet-monitor updated to use working time server (contributed by @rmontrosecbw)
• Tools
  • More flexible ESP-IDF version check
  • Include expected ESP-IDF version in esp32/manifest.json; use that everywhere the ESP-IDF version needs to be checked
  • mcrun has new -noCheckModule option to explicitly suppress generation of the check module. Replaces overload of -f x.
• XS
  • Optimize JavaScript stack use by Function.prototype.call, Function.prototype.apply, and Function.prototype.bind. Eliminates one stack frame, which benefits Piu initialization and ECMA-419 callbacks.
  • Merge better fix for undefined behaviors in fdlibm fmod
  • Fix native stack overflow on recursive Set (found by Fuzzilli)

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

This is an interim release with the following improvements:

• Expected ESP-IDF version now stored in only one location – the ESP32 device manifest
• Improve workaround for ESP-IDF v5.5 BLE bug to resolve link errors with some examples

Moddable SDK 5.10.0 contains improvements made between July 16, 2025 and August 12, 2025.

This is a relatively small release due to summer holidays and work on features that are not yet ready to publish.

ESP-IDF v5.5.0

The Moddable SDK has migrated to ESP-IDF v5.5.0 for all ESP32 family builds. The release contains many improvements by Espressif, particularly I²C and BLE. As usual, there should be no code changes required for the vast majority of projects using the Moddable SDK. Updating takes just a few minutes:

• If you used xs-dev to install the Moddable SDK, execute xs-dev update --device esp32
• Otherwise, follow the update instructions for macOS and Linux, or Windows.

ESP-IDF I²C Upgrade, again

In Moddable SDK 5.10.0, we've brought back support for Espressif's new i2c_master API. With ESP-IDF v5.5, the majority of issues appear to have been resolved. We are still working around one bug.

New ECMA-419 BLE Client, continued

This release contains numerous improvements to our new BLE Client and Web Bluetooth module. Thank you to @stc1988 and @mshioji for sharing their suggestions and observations. Learn about our new BLE Client in last month's release notes. We've also integrated our new BLE Client into Node-RED MCU Edition.

Release Details

• ECMA-419
  • BLE Client
    • Fix characteristic completion callback on macOS
    • Set target in constructor
    • UUID strings are lowercase (macOS)
    • Report scan errors (ESP32)
    • Ensure enableNotifications() fully completes before the next queued operation starts (ESP32)
    • Disable Espressif's auto-reconnect (ESP32)
    • Encode connection type into address to allow connecting to non-public addresses (ESP32)
    • Fix 128-bit UUID strings (ESP32)
    • Work around bug in ESP-IDF v5.5 NimBLE that disables notifications
    • Improve out-of-memory failure handling (ESP32)
• Modules
  • Web Bluetooth
    • getCharacteristics works for find all (contributed by @stc1988)
    • getPrimaryServices and getCharacteristics work when passed no arguments
    • Eliminate double new in properties getter (contributed by @stc1988)
    • removeEventListener fix for finding item (contributed by @stc1988)
    • Fix typo with writeWithOutResponse (contributed by @stc1988)
  • Migrate M5StackCoreTouch to ECMA-419 (contributed by @stc1988)
• Examples
  • io/ble – uuids are lowercase
• Documentation
  • Apply results of spell check run by @stc1988 to correct many small mistakes
  • Remove obsolete "id" references from Timer documentation (suggested by @stc1988)
• Tools
  • mcpack reports module format requested when reporting invalid module format
  • Workaround undefined left shift in fmod. This will likely change again in the next release to a more complete solution.
• Typings
  • Add Base64 & Hex to Uint8Array
  • Declarations for new ECMA-419 BLE client
  • Add default export for URL module
• Devices
  • Added creation to all ESP32 devices without one. These are required for optimal default memory partitions.

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 5.9.0 contains improvements made between June 12, 2025 and July 16, 2025.

Realtime AI Tools

Over recent months, we've updated our new Realtime AI Architecture with support for OpenAI, Google Gemini, Deepgram, ElevenLabs, and HumeAI. Our latest update isn't another AI service but support for "Functioning calling", sometimes called tools, where the AI service calls functions in your application to perform an action or retrieve information. Fortunately, the AI services have largely standardized how this is done, making it practical to support the same Function call interface in Moddable's Realtime AI architecture.

This release of the Moddable SDK includes a simple example to get you started. Check out the new ChatAudioIO-Tools example on ESP32, macOS, Windows, and Linux. The voice agent provides temperatures for locations in and around a home along with the ability to control the thermostat and air conditioning.

All new Bluetooth LE Central

This release contains a completely new API for implementing Bluetooth Centrals (also called BLE Clients). Our original Central has served us well for many years, but has some shortcomings that we wanted to address. Moddable has proposed this API to Ecma TC53 to become part of the ECMA-419 standard. The current draft API is available to read as part of the ECMA-419 4th Edition working draft.

We've created a suite of examples to help you get started with the new API. You can run these on ESP32 using the NimBLE stack or on macOS using Core Bluetooth. This is the first time we've supported Bluetooth in the simulator. This has proven to be incredibly powerful for accelerating Bluetooth development.

The new BLE Client is still experimental, so you can expect changes. But it is working very nicely, so we wanted to share it now to get experience and feedback while it is still evolving.

Web Bluetooth

This release also includes a new implementation of Web Bluetooth! This is built on our new BLE Client, making it available on ESP32 and macOS too. We've got an example to help you get started.

Web Bluetooth is a very high-level API, making it very pleasant to develop with. However, because it was designed for use in a web browser, it has many restrictions to protect the user's security. These don't always make sense on an embedded device In particular, the way a device is discovered isn't perfectly suited to embedded devices. Currently, the first matching device that is found is selected. This is imperfect and will evolve, but is sufficient for development.

ESP-IDF I²C downgrade

In Moddable SDK 5.8.0, the I²C support for ESP32 reverted from Espressif's new i2c_master to the previous I²C API due to a large number of issues reported. It appears the next ESP-IDF addresses at least some of these issues. Note that Moddable SDK 5.8.0 did not fully downgrade; specifically, the 419 I²C was downgraded but not the original Pins I²C. In Moddable SDK 5.9.0, both have been downgraded.

Release Details

• Modules
  • Deepgram support in ChatAudioIO now uses A-Law encoding for the user input to reduce bandwidth signficantly
  • ESP32 Ethernet driver replaces VSPI_HOST with SPI3_HOST (reported by @rmontrosecbw) #1509
  • New Web Bluetooth module
  • DS18X20 temperature sensor driver does reset before copying scratchpad (reported by @mauroForlimpopoli) #1514
• XS
  • BigInt.prototype.toString rewritten to be up to 30x faster
  • Added xsNewFunction* macros to xs.h to invoke constructors directly
  • Fix undefined left shift in the fdlibm implementation of fmod
  • Add fxAsyncFromSyncIteratorFailed to snapshot table
• ECMA-419
  • HTTP Client implements headersMask to parse only HTTP response headers that will be used
  • New BLE Client
• Examples
  • New examples for ECMA-419 BLE Client and Web Bluetooth
• Tools
  • xsbug displays BigInt values in base 10 (previously base 16)
  • xst fixes for garbage collection of timers (reported by @ChALkeR) #1515
  • mcconfig improvements for devices that use JTAG USB (reported by @mshioji)

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 5.8.0 contains improvements made between May 12, 2025 and June 11, 2025.

Realtime AI

This release sees our Realtime AI support continuing to expand with Deepgram joining our ChatAudioIO architecture. Deepgram's Voice Agent API provides realtime conversational AI support with a focus on enterprise applications.

Deepgram is noteworthy for being the only Realtime AI API using WebSockets to support binary transfer of audio data. This uses 25% less network bandwidth than the Base64 encoding used by everyone else; and requires less memory and CPU power to serialize and parse. Put another way, Deepgram is the lightest realtime AI service, which makes it a great choice for microcontroller projects.

Deepgram joins OpenAI, Google Gemini, ElevenLabs, and Hume AI in our ChatAudioIO. Imagine a single API that lets you easily build interactive voice chatbots with any of five leading AI services and do that efficiently on a low-cost microcontroller. And we're not done yet. Moddable has exciting updates planned. Stay tuned.

ESP-IDF I²C downgrade

Last month, the Moddable SDK's I²C support for ESP32 migrated to Espressif's new i2c_master API. Unfortunately, we have too many reports of issues from this change, including random read and write failures, and crashes when I²C and the JTAG USB connection are used simultaneously. Consequently, we've reverted the changes in this release. We will monitor the Espressif releases for improvements and try to report the issues encountered to Espressif.

Release Details

• Modules
  • ChatAudioIO - add support for Deepgram AI service
  • WebStorage – return null for missing elements to match HTML5
• ECMA-419
  • Analog input on ESP32 again works for multiple inputs (reported by @mshioji)
  • httpclient passes response's status text to onHeaders
  • fetch and EventSource use status text provided by httpclient
  • EventSource handles id property and missing options to constructor
  • Revert I²C API migration on ESP32 from previous release
• Devices
  • M5Atom S3R added (contributed by @kitazaki)
  • M5Atom Echo Base added (contributed by @kitazaki)
• XS
  • RegExp.escape() now supported. This is part of ES2025.
  • Immutable ArrayBuffer conformance improvements with latest test262
  • Import more math functions from fdlibm (for hosts that cannot use the platform mathlib)
  • String.prototype.fromCharCode conformance fix on integer input
  • Fix obscure marshalling native stack overflow (found by Fuzzilli)
  • Fix await lookahead token for arrow function with expression body (found by oss-fuzz)
  • Check meter on several more Array functions to trigger timeouts (found by oss-fuzz)
• Examples
  • mini-drag example reports incompatibility with ECMA-419 touch driver
• Tools
  • New M5Atom S3 simulator for mcsim (contributed by @stc1988)
  • mcconfig path corrected on builds of ESP32 on Linux when USE_USB is 1 (device using TinyUSB for xsbug connection)
• TypeScript
  • Add typings for Crypto Digest class (contributed by @stc1988)
  • Add optional second argument to Net.get() (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