aily Blockly: a general-purpose Blockly IDE for Arduino, ESP32 and STM32

What aily Blockly solves, and who it is actually for

Setting up an embedded toolchain is the part of hardware work that has nothing to do with the idea you started with. Board packages, compiler versions, USB drivers and library dependencies all have to line up before a single line of firmware runs. aily Blockly takes that setup on itself: the README describes it as a general-purpose hardware development environment rather than companion software for one board, and states that board packages, toolchains and common libraries are managed per project. The target user is explicit in the README, which says the early stage provides AI-assisted programming for non-professional users, while the long-term goal is to break the boundary between professional and non-professional development. In practice that means teachers, students, makers and product people who can describe what they want a device to do but do not want to spend an afternoon in a vendor's board manager. The README claims 100+ supported development boards and chips and 400+ preset extension libraries, and links separate repositories for boards, libraries and compilers rather than bundling everything in one tree.

How the Electron shell, Angular renderer and child processes fit together

The repository layout answers most of the architecture question. package.json sets main to electron/main.js, so the desktop shell is Electron, and the build configuration copies dist/aily-blockly/browser into a renderer directory, which is where the Angular UI runs. Angular is named in the README as the renderer-side framework for the main UI logic. The interesting part is the child directory and the afterPack hook scripts/package-child-resources.js: compiler and toolchain work is packaged as child resources rather than living inside the main process. extraResources also copies build/simulator-runtime into a simulator directory and child/scripts alongside it, so a simulator runtime ships with the application. Serial communication is handled through the serialport native module, which appears in asarUnpack with its @serialport dependency and the node-gyp-build and @lydell helpers; probe-rs is named in the README for talking to DAPLink and other debuggers. The build also registers abis and ailyblockly URL schemes for an OAuth protocol, and 7z is used to shrink large packages such as the ESP32 compiler. That combination explains why the README can promise compilation without a full vendor IDE: the heavy artifacts are downloaded and unpacked per project, then cached.

Installing aily Blockly and building a first project

There is no npm install path for end users. The README's Downloads section points to two builds, a China version at yiyu.pro/download and an international version at aily.pro/download, and the installer is the entry point. After installation the README says you only need to select a development board or chip to start building. The repository itself is a pnpm workspace: pnpm-workspace.yaml sits at the top level next to pnpm-lock.yaml, and package.json defines the electron-builder packaging that produces output under dist/aily-blockly/. A contributor working from source would install dependencies and run the Electron entry point, which package.json names as electron/main.js.

pnpm install

The packaged application is an Electron app, so the same entry point can be started directly during development.

npx electron electron/main.js

Inside the IDE the first real task is a project, not a file. The README describes the flow as selecting a board or chip, after which board packages, toolchains and libraries are managed per project. The AI features then operate on that project: project analysis to clarify requirements and recommend boards, modules and libraries, code generation that plans tasks and works through project dependencies, and compile-error analysis that reads the error output and suggests repairs. If a Blockly library is missing, the README says AI can analyze a native Arduino/C/C++ library and generate an adaptation, with the library specification documented in the aily-blockly-libraries repository. Expect the first project to spend its time on toolchain download rather than on blocks; that is the cost of the per-project model.

Alpha status, version churn and the wrong-tool cases

The README is unusually direct about the limits. It states that the project aims to be industrial-grade but is currently in the alpha stage and is not recommended for mass-production device firmware development, and that the current version is suitable for prototyping and education. A separate note says the alpha test version only guarantees minimum usability, that many planned highlight features have not yet been designed or developed, and that later adjustments may introduce incompatibilities between versions. The release history supports the second point: v0.9.98 on 2026-09-15, v0.9.97 on 2026-09-14, and v0.9.96 on 2026-08-31. The last push to the repository was on 2026-09-15, so the codebase is moving, but the version numbers are still in the 0.9 range. Treat project files as upgrade-sensitive. The other wrong-tool case is scale: a team shipping certified firmware needs reproducible builds, pinned toolchain versions and a signed release process, and the packaging configuration here sets forceCodeSigning to false. A project whose value depends on one specific vendor's proprietary IDE features will also get little from the board-agnostic approach. Finally, the AI features depend on an online service; the additional rights statement forbids removing the online service content and user agreement without authorization, so an offline-only deployment is not the intended shape.

How aily Blockly differs from the Arduino IDE and PlatformIO

Arduino IDE and PlatformIO both start from source files and add board management on top. aily Blockly starts from blocks and treats the source as output. That is not a cosmetic difference. In the Arduino IDE you install a board package, pick a board, and write a sketch; the editor is the center of the workflow. In PlatformIO you declare a board and framework in platformio.ini and the build system resolves dependencies per environment, which is a text-first, CI-friendly model. aily Blockly instead manages packages, toolchains and libraries per project through a graphical flow, and adds an AI layer that the README describes as participating from project analysis and wiring-diagram generation through code writing, compile-error analysis and debugging advice. If your team already has a working PlatformIO pipeline with pinned versions and automated tests, aily Blockly does not replace it. The comparison that matters is who is holding the keyboard: a non-professional user describing a device, or an engineer maintaining a build matrix. The README's own framing puts aily Blockly in the first camp for now.

Licence, packaging and what an upgrade costs

The project is GPL-3.0. The README's additional rights statement adds terms that a plain GPL reading would not give you: the software and derivative software based on it may not be sold without authorization, derivative products must not remove information about rights holders or sponsors and must ensure that information appears on the software startup page, and the online service content and user agreement must not be removed without authorization. The same statement carves out hardware works developed with the software, saying they are not restricted by the GPL and users may decide how to publish and use them. That split matters for anyone building a product around the tool. Upgrade cost is the practical worry. Releases arrive frequently, the README warns about incompatibilities between versions, and the build publishes updates through a generic provider at dl.yiyu.pro/blockly, with app-update.yml copied into resources, so the application can update itself. Board packages, compilers and libraries are separate repositories, which means a single IDE upgrade can pull in a different toolchain than the one that built your last working binary. This is a description of the licence terms, not legal advice; the terms themselves are in LICENSE and the README.

Editorial conclusion

Adopt aily Blockly for prototyping, classroom teaching and hobby projects on boards the project already ships packages for, and skip it for mass-production firmware: the README states the alpha version is not recommended for real work. Before committing, verify three things: that your exact board and chip appear in the aily-blockly-boards repository, that the library you depend on exists in aily-blockly-libraries or can be adapted from the native Arduino/C/C++ source, and that a project created in this release still opens after an upgrade, since the README warns that later adjustments may introduce incompatibilities between versions.

Frequently asked questions

Official sources

1. ailyProject/aily-blockly on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases