Firmware studio for constrained Python

MojoScale Studio

A browser-native developer product for ESP32-class devices: write focused Python, catch unsupported APIs before save, flash the right firmware, and keep iterating without local toolchains.

Python Lint Flash Wireless update AI model aware

Open Studio See workflow

Fast, easy development A focused Python subset for device logic, sensors, callbacks, and camera workflows.

No toolchains Create projects and flash from the browser with the matching firmware selected for the board.

Wireless code updates After the firmware is on the device, script changes can move without a full rebuild cycle.

Constrained Python

Small syntax, clear device behavior, fewer surprises.

MojoScale Studio is intentionally narrower than desktop Python. The editor knows the supported modules, the docs panel shows the available APIs, and the linter can stop code that firmware cannot run.

Supported imports are explicit Modules such as system, camera, cv, gpio, i2c, and display drivers are documented inside the IDE.

Firmware options stay attached to the project Chip, flash size, BLE mode, and model selection travel with the project so flashing uses the right artifacts.

Errors show before the board is touched Syntax and lint errors are surfaced in the editor and on save, before a user starts flashing.

main.py

1
2
3
4
5
6
7
8
9
10
11
12
13

import system
import camera
import cv

camera.begin("xiao_s3_sense")
cv.load("hand_detect")

def tick():
    result = cv.detect_camera()
    if result["found"]:
        print(result)

system.schedule("tick", 500, 500, -1, tick)

Native performance path

Write Python, get native-code-level performance where it matters.

The user writes constrained Python, but the heavy work runs through firmware-native modules compiled for the board. Python becomes the clean control layer; GPIO, camera capture, displays, networking, and AI model execution stay on fast native paths.

Readable scripts for product logic Users describe behavior in small Python files instead of editing embedded C++ for every change.

Native modules for hardware work The firmware owns timing-sensitive drivers and compute-heavy operations, so scripts orchestrate instead of grinding through slow userland code.

Static checks before deployment The IDE can reject unsupported syntax, unknown modules, invalid callbacks, and model mistakes before the board runs anything.

Constrained Python Small scripts, explicit imports, documented firmware APIs.

developer speed

Lint and translate Validate the supported surface and prepare board-ready runtime code.

early errors

Native firmware modules Drivers, camera, networking, storage, and model execution stay inside compiled firmware.

native paths

The path from idea to board

Write code, choose the target, flash once, then update wirelessly.

The workflow is built for product users and field teams who need firmware behavior, not a local embedded development environment.

Create a Studio project

Name the script and choose the supported board target. ESP32-S3 is the first supported chip.

Write constrained Python

Use the documented device APIs and get syntax, module, callback, and model checks as you save.

Flash from the browser

The app pulls the correct firmware, filesystem image, script, and optional model artifact for the project.

Update code over the air

Once deployed, script changes can be shipped wirelessly without reinstalling a toolchain or rebuilding firmware.

What users avoid

No heavyweight setup just to change board behavior.

MojoScale Studio keeps the advanced firmware pieces behind the scenes while exposing the parts users actually need: code, docs, validation, firmware target, and flash.

No local ESP-IDF setup

Browser-first flashing

Users can connect a board and flash supported builds from the web UI instead of installing embedded build tools locally.

No mystery syntax

Docs match the linter

The same stub-driven surface powers docs, suggestions, lint checks, and transpilation, so supported APIs stay consistent.

No full rebuild for every script

Wireless script updates

Firmware handles the runtime, and the user-facing script can be updated as the project evolves.

Start building

Open Studio and create your first device script.

Start with a small Python file, choose ESP32-S3, and let the app handle the firmware path.

Open Studio