# BlocklyDuino turns drag and drop blocks into Arduino source you can upload

> BlocklyDuino is a browser based visual editor for Arduino built on Blockly, with Grove sensor blocks, examples loadable from a URL and a small Python server that pushes the generated code to a connected board. The v1 branch stopped at 2015 releases while a v2 branch exists separately.

**BlocklyDuino/BlocklyDuino** — BlocklyDuino is a web-based visual programming editor for arduino.

- Repository: https://github.com/BlocklyDuino/BlocklyDuino
- Stars: 645 · Forks: 350
- Language: JavaScript
- License: not declared
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/blocklyduino-blocklyduino

## Blockly blocks, an Arduino tab, and a real board

BlocklyDuino is a web based visual programming editor for Arduino, built on Blockly, the graphical programming editor that Google developed for the visual programming of children. The project adds what Blockly does not have: blocks with static types, and code generators that emit Arduino source. The workflow it enables is deliberately split into two halves, and understanding that split explains the tool. You compose a program by dragging and dropping blocks in the browser, then you switch to the Arduino tab and copy the generated source into an existing or new project in the Arduino IDE, where you press Upload to burn the code onto a connected board. The generated code is described as fully compatible Arduino source, which is the point: nothing about the output is proprietary, and a student who outgrows the blocks has the same code in the normal toolchain. The project is also inspired by ardublock and modkit, and the README credits the Blockly authors and a contributor for the Python server that pipes the source to the board.

## Grove blocks bring sensor hardware into the block palette

Beyond the plain Arduino blocks, BlocklyDuino ships Grove blocks, described as support for the Grove system from Seeed Studio, so that people can get started with microcontroller experimentation and learning without wiring a sensor from raw components. The features list mentions more than ten predefined Grove sensor blocks and an interactive Arduino board, which is the difference between a tool that can compile a blinking LED sketch and one that can read a sensor. For a classroom the practical effect is large: the wiring is reduced to plugging a module into a Grove port, and the program is assembled from blocks that name the sensor rather than from pin numbers and register calls. The block editor is still the general Blockly interface, so the standard categories of control, logic and arithmetic blocks are all there, and the generated code is ordinary Arduino that a learner can later read and adapt.

## Examples load through a URL parameter, which makes sharing easy

One of the nicer touches is that BlocklyDuino can load a workspace from a url parameter, and the README demonstrates three worked examples that way. The first makes the default LED blink, the second controls a servo with a potentiometer, and the third uses a button to change LED colours. Each one is a link to the hosted editor with a url argument pointing at an example file, for example the blink example in the examples directory. The feature is listed in the features section as loading different on-site examples with url parameters, and it matters for two different audiences. For a teacher, a lesson becomes a link that a student can click. For a workshop, a working configuration becomes something you can send to a colleague instead of describing. It also makes the hosted deployment at the project's GitHub Pages site the primary way most people meet the tool, since the examples are links into that deployment rather than files you have to host yourself.

## Running it locally means serving a folder or opening one file

If you want to install it locally, the README says to get the code from GitHub and open the blockly/apps/blocklyduino/index.html file in your browser. The preferred way, it says, is to put the BlocklyDuino/web folder into a web server and open the url for the index page under the public path. The distinction matters because a visual editor loads several scripts and assets, and opening the file directly from disk will often hit browser restrictions on local file access. The top level listing shows how little is involved: a .gitignore, a CHANGELOG.txt, the README, the arduino_web_server.py script, a blockly directory and a v2 directory. There is no build step to speak of and no package manager configuration, which is a reflection of the era the project comes from, when the Blockly tree was checked in and used directly.

## The Python server removes the copy and paste step

The integrated upload path is the feature that makes BlocklyDuino feel like a single tool rather than two. To avoid the tedious step of manually pasting code into the Arduino IDE, you can run a small web server that uses the Arduino IDE to upload the code to a connected board, and it works on Windows, Mac OS X and Linux. The command is run from the BlocklyDuino root folder.

```shell
python arduino_web_server.py 
```

You can optionally specify the port, with a COM port on Windows and a device path on Linux and Mac, and if you do not, the server will try to guess which port to use.

```shell
python arduino_web_server.py --port=/dev/ttyUSB0
```

With the server running, BlocklyDuino is served on the local address port 8080, and the workflow changes to pressing Upload directly in the editor, with a Reset button available to upload an empty program. The README walks through the Linux case in detail, opening a terminal to run the server with an explicit port, opening a browser at the local address, loading an example with the LoadXML button, pressing Upload and waiting for a Program uploaded ok message, then closing the terminals. That is a complete classroom procedure in five steps.

## Two versions, tags from 2015 and an unclear licence in the listing

The project structure raises a question for anyone picking it up. The default branch is v1-gh-pages, and the very first line of the README points readers to BlockDuino v2 in a separate tree, so the v1 documentation you are reading is not the whole project. The release list confirms the vintage, with v1.2 from February 2015, v1.3 from June 2015 and v1.4 from August 2015, while the last push was on 2026-08-10, so the branch is still receiving changes even though the tags stopped a decade ago. The licence is the other loose end. The README states Apache License Version 2.0 with the copyright line running from 2012 to 2015, while the repository listing reports no licence identifier, so the Apache 2.0 statement in the README is what a legal reviewer should read. The credits also date the project clearly, naming Fred Lin as the author, thanking the Blockly contributors Neil Fraser and Q. Neutron, and crediting Dale Low with the Python server contribution. A CHANGELOG.txt file in the tree, linked from the README, is where the release history lives.

## Conclusion

BlocklyDuino suits a classroom or a workshop where participants have never written a line of Arduino and need a program running on a board in a minute, because the block editor produces source that the standard IDE accepts and the local server removes the copy and paste step. It is the wrong tool for a project that will grow past a first sketch, since the generated code has to be carried into the IDE by hand in the v1 workflow, and the wrong tool if you need an actively maintained project, because the latest tagged releases are v1.2, v1.3 and v1.4 from 2015 while the last push was on 2026-08-10. Verify three things before you build a course on it: that the v1 branch you are reading is the one you want, since the README points readers to a separate v2 tree, that the browser build still loads current Blockly blocks, and that the Apache 2.0 statement in the README, which the repository listing does not reflect with a licence identifier, covers your use.

## FAQ

### How do I run BlocklyDuino on my own machine?

The README says to get the code from GitHub and open blockly/apps/blocklyduino/index.html in your browser, though it calls the preferred method putting the BlocklyDuino/web folder into a web server and opening the index page under the public path.

### Can BlocklyDuino upload code to an Arduino board directly?

Yes, if you run the bundled mini web server with python arduino_web_server.py, optionally with a port argument such as --port=/dev/ttyUSB0 on Linux. The server uses the Arduino IDE to upload the code, and the editor is then served on port 8080 with an Upload button.

### What hardware do the Grove blocks support?

BlocklyDuino includes Grove blocks from Seeed Studio, with more than ten predefined Grove sensor blocks, so that microcontroller experiments and learning can start without wiring sensors from raw components. The features list also describes an interactive Arduino board.

### How do I share a BlocklyDuino example?

Examples are loaded through a url parameter, and the README links three of them, a blinking LED, a servo controlled by a potentiometer and a button that changes LED colours. The same mechanism works for the LoadXML button in the editor for files inside the project directory.

## Sources

- [BlocklyDuino/BlocklyDuino on GitHub](https://github.com/BlocklyDuino/BlocklyDuino)
- [Issues](https://github.com/BlocklyDuino/BlocklyDuino/issues)
- [README](https://github.com/BlocklyDuino/BlocklyDuino/blob/v1-gh-pages/README.md)
- [Releases](https://github.com/BlocklyDuino/BlocklyDuino/releases)

---

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