TinyGo VS MicroPython

In my experience it is pretty difficult to make WASM faster than JS unless your JS is really crappy and inefficient to begin with. LLVM-based WASM is your best bet to surpass vanilla JS, but even then it's not a guarantee.

Go's WASM tooling isn't as good since it doesn't use LLVM and I've found it very difficult to even get parity with vanilla JS performance. There is a way to use a subset of go with llvm for faster wasm ([tinygo](https://tinygo.org/)).

I'm hoping that Microsoft might use some of their wasm chops to improve GO's native wasm compiler. Their .NET wasm compiler is pretty darn good, especially if you enable AOT.

Built a platform flibbert.com where you can run code on ESP32 microcontrollers in AssemblyScript and TinyGo. It’s great for trying things out or learning without the usual setup hassle. Would love for people to try it and share feedback! (The project is on early stage, tested only on esp32-cam)

So, I chose another way. In other words, the approach is to convert it into WASM using TinyGo.

it's not an embeddable runtime like Lua

While it's true you can't have multiple MicroPython interpreters running concurrently (or at least not easily; it's not that the design makes this impossible, it's just that all in all MicroPython is fairly young and development focus has been put elsewhere), it is possible to embed MicroPython. Not completely out of the box, needs some glue code etc. See for example https://github.com/micropython/micropython/tree/master/ports....

It's obviously not directly comparable - each port will be different - but startup time is <50ms on an RP2040 (Cortex M0 @133MHz):

https://github.com/micropython/micropython/issues/8420

Yes, although MicroPython is focused on running on microcontrollers it can be useful if you want to reduce memory consumption, flash space and even startup time on servers.

The challenge is that MicroPython has many fewer standard libraries:

https://github.com/micropython/micropython/wiki/Standard-Lib...

And so many Python libraries targeting CPython won't work out-of-the box and you'll need to modify them or use alternatives that do work on the MicroPython subset.

I'll link to it because many people don't know a version of Python runs on microcontrollers:

https://micropython.org/

I'm personally working on something like this for the ESP32, but written on top of micropython [1]. A few things are written in C such as the display driver, but otherwise most things are in micropython. We chose the T-Watch 2020 V3 microphone variant as the platform [2].

Our objective is to build a modern PDA device via a mostly stand-alone watch that can be synced across devices (initially the Linux desktop). We want to achieve tasks that you might typically do on your desktop, focussed towards productivity.

We did consider a custom OS, but decided against it for a few reasons:

1. Allowing somebody else to handle basic OS stuff allows us to concentrate on what really matters, the higher level stuff on top.

2. Having multiple threads in micropython is super simple and we are able to run many active apps at the same time, rather than having to kill them off [3]. Our background apps can continuously interact with the network in the background.

3. Code written for micropython can be easily run on other Python-capable devices.

[1] https://micropython.org/

[2] https://lilygo.cc/products/t-watch-2020-v3

[3] https://tactility.one/#/application-lifecycle

tools/mpy_ld.py: https://github.com/micropython/micropython/blob/master/tools...

tools/mpy-tool.py lists opcodes: https://github.com/micropython/micropython/blob/master/tools...

Can the same be done with .pyc files; what are the advantages of MicroPython native modules?

Why does it need wasm2c?