# Stack-chan: a JavaScript robot on M5Stack hardware, from flashing to writing MODs

> Stack-chan is an open-source M5Stack robot whose firmware, MODs, browser tools, cases and schematics live in one Apache-2.0 repository. The interesting part is that you can flash it and write a MOD without installing the Moddable SDK or ESP-IDF.

**stack-chan/stack-chan** — A JavaScript-driven M5Stack-embedded super-kawaii robot.

- Repository: https://github.com/stack-chan/stack-chan
- Stars: 1,738 · Forks: 227
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-09-14 · Updated: 2026-09-14 · Language: en
- Canonical page: https://hysenlabs.com/projects/stack-chan-stack-chan

## What Stack-chan actually ships, and who the repository is for

The README describes Stack-chan as an open-source, JavaScript-driven robot built with M5Stack, and the repository is a bundle rather than a single program: firmware, user applications the project calls MODs, browser development tools, 3D-printable cases and schematics. That mix tells you who it is for. Someone who wants a finished appliance will find a hardware shopping list and a build path. Someone who wants a small robot they can change in JavaScript gets the firmware, a simulator, a block editor and a gallery of published MODs in the same place.

The project's own getting-started path assumes you begin with a preassembled M5StackChan and the browser tools, not with a compiler. The standard configuration is M5StackChan CoreS3, and the README states that this is the target used for physical-device release validation. That sentence matters more than the feature list: it means other boards are supported by the distributed firmware, but the CoreS3 is the one the project validates on real hardware. The joystick remote controller is described as optional, so it is not part of the minimum path.

## How a MOD runs: firmware, MODs and the WebAssembly simulator

The architecture visible in the repository separates a host firmware from the applications on top of it. The firmware directory holds the host firmware, modules, MODs and development scripts. A MOD is the project's term for a user application, and the README points to a separate MOD development guide plus a firmware API document. That split is the core design decision: the host owns the device, and MODs sit above it against a documented API rather than against the hardware directly.

Two consequences follow from that layout. First, the same MOD can run in more than one place. The browser tools include a simulator that runs MODs against a WebAssembly build of the firmware with a 3D model, and the MOD Gallery lets you run a MOD in the simulator or install it on a device. Second, the tooling is browser-first. There is a Blockly-based block editor for creating MODs, and the README notes that block-based samples can be opened directly in the editor and changed. For a JavaScript robot, that is an unusual choice: the entry point is a browser tab, not a local toolchain.

The hardware side is documented separately. Cases live under case/ with a case guide for parts and assembly, and board information lives under schematics/. Firmware for Stack-chan RT and Takao Core2 + SG90 can be built from source, with target-specific commands and constraints in the firmware guide. So the repository covers the whole path from board files to a running MOD, but each stage has its own document.

## Flashing Stack-chan firmware and running your first MOD

The README's getting-started sequence has three steps and deliberately avoids a local SDK install. You need an M5StackChan, a data-capable USB cable, and Chrome or Edge. The project states that you do not need to install the Moddable SDK or ESP-IDF for this path.

Open the Web firmware installer and select the device. The README gives "M5StackChan CoreS3" as the device name to choose:

```text
https://stack-chan.github.io/stack-chan/web/flash/
```

After flashing, the device is running this repository's firmware. The README warns that this replaces the factory firmware supplied by M5Stack, and that restoring it means following the restore procedure in the M5Stack product documentation and using M5Burner. Treat that as a one-way step until you have read the restore instructions.

Next, find a MOD. The MOD Gallery is where published MODs and mini apps are listed, and each one can be run in the simulator or installed on a device:

```text
https://stack-chan.github.io/stack-chan/web/mod-gallery/
```

If you would rather change something than install something, the block editor is the shortest path. The README says block-based samples can be opened directly in the editor and modified, and that the editor can run a MOD in the simulator or on a device. Device preferences such as Wi-Fi are changed over BLE through the Preferences tool rather than by reflashing, which is the reason the browser tools are listed as a set and not as separate utilities.

## Where Stack-chan stops being the right tool

The clearest limitation is the one the README states outright: flashing this firmware replaces the factory firmware, and restoring it is an M5Stack procedure involving M5Burner, not something the repository automates. The README does not document a rollback path of its own. If the device is your only M5Stack and you depend on what shipped on it, that is a real cost.

The second limitation is hardware coverage. The distributed firmware supports M5Stack, M5Stack Core2, M5Stack CoreS3 and M5StackChan CoreS3, but validation happens on M5StackChan CoreS3. Stack-chan RT and Takao Core2 + SG90 require building firmware from source, which puts you back into the toolchain the browser installer was designed to avoid. There is no single firmware for every board the project has ever touched.

The third is scope. Stack-chan is a robot with a face, a body and a case, not a general ESP32 development board. If your goal is a sensor node, a display dashboard or anything that does not benefit from the robot form factor, the case models, the face editor and the MOD Gallery are weight you would carry for nothing. The repository is also explicit that it distributes resources rather than a product: the README links to M5Stack's store for the hardware in several regions, and the case and schematic directories exist because building your own is an expected path, not an edge case.

## Stack-chan against a plain M5Stack firmware project

The obvious alternative is to program the same M5Stack board directly with ESP-IDF or the Arduino framework and skip Stack-chan entirely. The difference is not language preference, it is where the abstraction sits. With a plain firmware project you own the whole binary: you write the display code, the servo behaviour and the network stack, and nothing sits between you and the hardware. Stack-chan inverts that. The host firmware is fixed unless you build it yourself, and your work goes into a MOD that talks to the firmware through the API documented in the firmware API file.

That trade buys portability across two runtimes. A MOD can run in the WebAssembly simulator with a 3D model before it ever touches a device, and the same MOD can be installed on hardware from the Gallery. A plain firmware project gives you no equivalent: you flash to find out. It also buys the block editor, which matters if the person writing the MOD is not the person who set up the toolchain.

What you give up is low-level control and the freedom to change the host behaviour without forking the firmware. If your project needs timing guarantees or peripheral access the API does not expose, the abstraction is a ceiling, not a convenience. The project's own repository layout reflects this: firmware, MODs and API documentation are separate trees because they are separate concerns with different owners.

## Maintenance, releases and the Apache-2.0 licence

The last push to the repository was on 2026-09-12, and the most recent release is v1.1.0 from 2026-08-25, following v1.0.0 on 2026-07-21. There is a long gap before that: v1.0.0rc dates to 2023-10-23. So the 1.x line is recent, and the jump from a 2023 release candidate to a 2026 1.0 suggests a period where tagged releases were not the main channel. The repository is not archived, and it carries a development roadmap document, a contribution guide and a changesets directory, which is the tooling a project uses when it intends to publish versioned changes.

Upgrade cost depends on which layer you touched. If you only install published MODs and change preferences over BLE, a firmware release is a reflash through the browser installer and your settings live outside the binary. If you write MODs, the firmware API document is the contract to check before upgrading, since a MOD is written against the host rather than against the board. If you build firmware from source for a non-standard target, you are tracking the develop branch, which is the default branch here, and you own the merge work.

Licensing is straightforward on its face: the repository's resources are distributed under the Apache License 2.0, with the LICENSE file at the root. That covers the firmware, the web tools, the case models and the schematics as repository resources. It says nothing about the M5Stack hardware you buy, which is a separate product with its own terms, and it says nothing about MODs published by other people, which may carry their own licences. The README also links a GitHub Sponsors page for financial support, which is separate from the licence grant.

## Conclusion

Adopt Stack-chan if you want a small M5Stack robot you can reprogram in JavaScript and are willing to buy or build the hardware first, since the repository ships firmware, MODs, cases and schematics rather than a finished product. Skip it if you need a general-purpose ESP32 application platform or cannot accept that flashing replaces the factory firmware and restoring it means going back through M5Burner and the M5Stack product documentation. Before buying anything, confirm which board you have against the supported hardware list, because the distributed firmware covers M5Stack, M5Stack Core2, M5Stack CoreS3 and M5StackChan CoreS3, while Stack-chan RT and Takao Core2 + SG90 firmware has to be built from source. Then open the Web firmware installer in Chrome or Edge and check that your device appears before you plan the rest of the build.

## FAQ

### What is Stack-chan?

Stack-chan is an open-source, JavaScript-driven robot built with M5Stack. The repository provides firmware, user applications called MODs, browser development tools, cases and schematics.

### How do I set up Stack-chan?

Get an M5StackChan, connect it to a computer with a data-capable USB cable, then open the Web firmware installer in Chrome or Edge and select "M5StackChan CoreS3" as the device. The README states you do not need to install the Moddable SDK or ESP-IDF for this path.

### How much does the Stack-chan robot cost?

The repository does not list prices. The README links to the M5Stack Official Store for worldwide orders and to M5StackChan listings in Japan, and notes that the joystick remote controller is optional.

## Sources

- [Issues](https://github.com/stack-chan/stack-chan/issues)
- [License: Apache-2.0](https://github.com/stack-chan/stack-chan/blob/develop/LICENSE)
- [README](https://github.com/stack-chan/stack-chan/blob/develop/README.md)
- [Releases](https://github.com/stack-chan/stack-chan/releases)
- [stack-chan/stack-chan on GitHub](https://github.com/stack-chan/stack-chan)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/stack-chan-stack-chan