+
+# 
Wasm3
+
+[](https://wapm.io/package/vshymanskyy/wasm3)
+[](https://github.com/wasm3/wasm3/issues)
+[](https://github.com/wasm3/wasm3/actions)
+[](https://bugs.chromium.org/p/oss-fuzz/issues/list?can=1&q=proj:wasm3)
+[](https://github.com/wasm3/wasm3)
+
+The fastest WebAssembly interpreter, and the most universal runtime.
+Based on [**CoreMark 1.0**](./docs/Performance.md) and [**independent**](https://00f.net/2021/02/22/webassembly-runtimes-benchmarks) benchmarks. Your mileage may vary.
+
+
+[](https://twitter.com/wasm3_engine)
+[](https://discord.gg/qmZjgnd)
+[](https://t.me/joinchat/DD8s3xVG8Vj_LxRDm52eTQ)
+
+## Getting Started
+
+Here's a small [getting started guide](https://wapm.io/package/vshymanskyy/wasm3). Click here to start:
+
+[](https://webassembly.sh/?run-command=wasm3)
+
+
+## Installation
+
+**Please follow the [installation instructions](./docs/Installation.md).**
+
+Wasm3 can also be used as a library for:
+
+[
Python3](https://github.com/wasm3/pywasm3) │
+[
Rust](https://github.com/Veykril/wasm3-rs) │
+[
C/C++](https://github.com/wasm3/wasm3) │
+[
GoLang](https://github.com/matiasinsaurralde/go-wasm3) │
+[ Zig](https://github.com/alichay/zig-wasm3)
+[
Swift](https://github.com/shareup/wasm-interpreter-apple) │
+[
.Net](https://github.com/tana/Wasm3DotNet) │
+[
Arduino, PlatformIO, Particle](https://github.com/wasm3/wasm3-arduino)
+
+
+## Status
+
+`wasm3` passes the [WebAssembly spec testsuite](https://github.com/WebAssembly/spec/tree/master/test/core) and is able to run many `WASI` apps.
+
+Minimum useful system requirements: **~64Kb** for code and **~10Kb** RAM
+
+`wasm3` runs on a wide range of architectures (`x86`, `x86_64`, `ARM`, `RISC-V`, `PowerPC`, `MIPS`, `Xtensa`, `ARC32`, ...) and [platforms](/platforms):
+- 
Linux,
+
Windows,
+
OS X,
+
FreeBSD,
+
Android,
+
OpenWrt, Yocto, Buildroot (routers, modems, etc.)
+- 
Raspberry Pi, Orange Pi and other SBCs
+- 
MCUs: Arduino, ESP8266, ESP32, Particle, ... [see full list](./docs/Hardware.md)
+- 
Browsers. Yes, using WebAssembly itself!
+- 
`wasm3` can execute `wasm3` (self-hosting)
+
+## Advanced features and [post-mvp proposals](https://github.com/WebAssembly/proposals) support
+
+☑ Sign-extension operators
+☑ Non-trapping float-to-int conversions
+☑ Import/Export of Mutable Globals
+☑ Structured execution tracing
+☑ Big-Endian systems support
+☑ Self-hosting
+☑ Gas metering
+☑ Multi-value
+☐ Reference types
+☐ Bulk memory operations
+☐ Tail call optimization
+
+## Motivation
+
+**Why use a "slow interpreter" versus a "fast JIT"?**
+
+In many situations, speed is not the main concern. Runtime executable size, memory usage, startup latency can be improved with the interpreter approach. Portability and security are much easier to achieve and maintain. Additionally, development impedance is much lower. A simple library like Wasm3 is easy to compile and integrate into an existing project. (Wasm3 builds in a just few seconds). Finally, on some platforms (i.e. iOS and WebAssembly itself) you can't generate executable code pages in runtime, so JIT is unavailable.
+
+**Why would you want to run WASM on embedded devices?**
+
+Wasm3 started as a research project and remains so by many means. Evaluating the engine in different environments is part of the research. Given that we have `Lua`, `JS`, `Python`, `Lisp`, `...` running on MCUs, `WebAssembly` is actually a promising alternative. It provides toolchain decoupling as well as a completely sandboxed, well-defined, predictable environment. Among practical use cases we can list `edge computing`, `scripting`, running `IoT rules`, `smart contracts`, etc.
+
+## Used by
+
+[
](https://wasmcloud.dev/)
+[
](https://wowcube.com/)
+[
](https://scailable.net/)
+[
](https://blynk.io/)
+[
](https://www.iden3.io/)
+[
](https://github.com/kateinoigakukun/wasmic-ios)
+[
](https://github.com/balena-io-playground/balena-wasm3)
+[
](https://github.com/deislabs/krustlet-wasm3)
+[
](https://shareup.app/blog/introducing-shareup/)
+[
](https://github.com/saghul/txiki.js)
+
+## Further Resources
+
+[Demos](./docs/Demos.md)
+[Installation instructions](./docs/Installation.md)
+[Cookbook](./docs/Cookbook.md)
+[Troubleshooting](./docs/Troubleshooting.md)
+[Build and Development instructions](./docs/Development.md)
+[Supported Hardware](./docs/Hardware.md)
+[Testing & Fuzzing](./docs/Testing.md)
+[Performance](./docs/Performance.md)
+[Interpreter Architecture](./docs/Interpreter.md)
+[Logging](./docs/Diagnostics.md)
+[Awesome WebAssembly Tools](https://github.com/vshymanskyy/awesome-wasm-tools/blob/main/README.md)
+
+### License
+This project is released under The MIT License (MIT)
diff --git a/wasm3-sys/wasm3/docs/Cookbook.md b/wasm3-sys/wasm3/docs/Cookbook.md
new file mode 100644
index 0000000..8dd9241
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Cookbook.md
@@ -0,0 +1,409 @@
+# WASM module examples
+
+### Rust WASI app
+
+Create a new project:
+```sh
+$ cargo new --bin hello
+$ cd hello
+$ rustup target add wasm32-wasi
+```
+
+Build and run:
+```sh
+$ cargo build --release --target wasm32-wasi
+
+$ wasm3 ./target/wasm32-wasi/release/hello.wasm
+Hello, world!
+```
+
+### AssemblyScript WASI app
+
+Create `hello.ts`:
+```ts
+import "wasi"
+import {Console} from "as-wasi"
+
+Console.log('Hello World!');
+```
+
+Create `package.json`:
+```json
+{
+ "scripts": {
+ "asbuild:debug": "asc hello.ts -b hello.wasm --debug",
+ "asbuild:optimized": "asc hello.ts -b hello.wasm -O3s --noAssert",
+ "asbuild:tiny": "asc hello.ts -b hello.wasm -O3z --noAssert --runtime stub --use abort=",
+ "build": "npm run asbuild:optimized"
+ },
+ "devDependencies": {
+ "assemblyscript": "*",
+ "as-wasi": "*"
+ }
+}
+```
+
+Build and run:
+```sh
+$ npm install
+$ npm run build
+
+$ wasm3 hello.wasm
+Hello World!
+```
+
+### TinyGo WASI app
+
+Create `hello.go`:
+```go
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Printf("Hello, %s!\n", "world")
+}
+```
+
+Build and run:
+```sh
+$ tinygo build -o hello.wasm -target wasi -no-debug hello.go
+
+$ wasm3 hello.wasm
+Hello, world!
+```
+
+### Zig WASI app
+
+Create `hello.zig`:
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ const stdout = std.io.getStdOut().writer();
+ try stdout.print("Hello, {s}!\n", .{"world"});
+}
+```
+
+Build and run:
+```sh
+$ zig build-exe -O ReleaseSmall -target wasm32-wasi hello.zig
+
+$ wasm3 hello.wasm
+Hello, world!
+```
+
+## Zig library
+
+Create `add.zig`:
+```zig
+export fn add(a: i32, b: i32) i64 {
+ return a + b;
+}
+```
+
+Build and run:
+```sh
+$ zig build-lib add.zig -O ReleaseSmall -target wasm32-freestanding
+
+$ wasm3 --repl add.wasm
+wasm3> add 1 2
+Result: 3
+```
+
+### C/C++ WASI app
+
+The easiest way to start is to use [Wasienv](https://github.com/wasienv/wasienv).
+
+Create `hello.cpp`:
+```cpp
+#include
+ } = 0
+ malloc (i32: 2) {
+ dlmalloc (i32: 2) {
+ } = 131232
+ } = 131232
+ wasi_unstable!fd_prestat_dir_name(3, 131232, 1) { } = 0
+ __wasilibc_register_preopened_fd (i32: 3, i32: 131120) {
+ po_map_assertvalid (i32: 131088) {
+ }
+ po_map_assertvalid (i32: 131088) {
+ }
+ strdup (i32: 131232) {
+ strlen (i32: 131232) {
+ } = 1
+ malloc (i32: 2) {
+ dlmalloc (i32: 2) {
+ } = 131248
+ } = 131248
+ memcpy (i32: 131248, i32: 131233, i32: 131232) {
+ } = 131248
+ } = 131248
+ wasi_unstable!fd_fdstat_get(3, 65496) { } = 0
+ po_map_assertvalid (i32: 131088) {
+ }
+ po_map_assertvalid (i32: 131088) {
+ }
+ } = 0
+ free (i32: 131232) {
+ dlfree (i32: 131232) {
+ }
+ }
+ wasi_unstable!fd_prestat_get(4, 65528) { } = 0
+ malloc (i32: 2) {
+ dlmalloc (i32: 2) {
+ } = 131232
+ } = 131232
+ wasi_unstable!fd_prestat_dir_name(4, 131232, 1) { } = 0
+ __wasilibc_register_preopened_fd (i32: 4, i32: 131120) {
+ po_map_assertvalid (i32: 131088) {
+ }
+ po_map_assertvalid (i32: 131088) {
+ }
+ strdup (i32: 131232) {
+ strlen (i32: 131232) {
+ } = 1
+ malloc (i32: 2) {
+ dlmalloc (i32: 2) {
+ } = 131264
+ } = 131264
+ memcpy (i32: 131264, i32: 131233, i32: 131232) {
+ } = 131264
+ } = 131264
+ wasi_unstable!fd_fdstat_get(4, 65496) { } = 0
+ po_map_assertvalid (i32: 131088) {
+ }
+ po_map_assertvalid (i32: 131088) {
+ }
+ } = 0
+ free (i32: 131232) {
+ dlfree (i32: 131232) {
+ }
+ }
+ wasi_unstable!fd_prestat_get(5, 65528) { } = 8
+ __wasm_call_ctors () {
+ }
+ __original_main () {
+ printf (i32: 65536, i32: 0) {
+ vfprintf (i32: 69512, i32: 0, i32: 65536) {
+ printf_core (i32: 0, i32: -1, i32: 65536, i32: -16, i32: 65480) {
+ } = 0
+ __towrite (i32: 69512) {
+ } = 0
+ printf_core (i32: 69512, i32: 8, i32: 65536, i32: -1, i32: 65480) {
+ __fwritex (i32: 65536, i32: 0, i32: 7) {
+ memcpy (i32: 68472, i32: 0, i32: 65536) {
+ } = 68472
+ } = 7
+ __fwritex (i32: 65543, i32: 0, i32: 0) {
+ memcpy (i32: 68479, i32: 0, i32: 65543) {
+ } = 68479
+ } = 0
+ pop_arg (i32: 64456, i32: 0, i32: 9) {
+ }
+ strnlen (i32: 65548, i32: 0) {
+ memchr (i32: 65548, i32: 4, i32: 0) {
+ } = 65553
+ } = 5
+ __fwritex (i32: 67222, i32: 65553, i32: 0) {
+ memcpy (i32: 68479, i32: 0, i32: 67222) {
+ } = 68479
+ } = 0
+ __fwritex (i32: 65548, i32: 65553, i32: 5) {
+ memcpy (i32: 68479, i32: 0, i32: 65548) {
+ } = 68479
+ } = 5
+ __fwritex (i32: 65545, i32: 0, i32: 2) {
+ __stdout_write (i32: 69512, i32: 0, i32: 65545) {
+ __isatty (i32: 1) {
+ wasi_unstable!fd_fdstat_get(1, 64376) { } = 0
+ } = 1
+ __stdio_write (i32: 69512, i32: 64368, i32: 65545) {
+ writev (i32: 1, i32: -16, i32: 64384) {
+Hello, world!
+ wasi_unstable!fd_write(1, 64384, 2, 64380) { } = 0
+ } = 14
+ } = 2
+ } = 2
+ memcpy (i32: 68472, i32: -1, i32: 65547) {
+ } = 68472
+ } = 2
+ } = 14
+ } = 14
+ } = 14
+ } = 0
+ __prepare_for_exit () {
+ dummy () {
+ }
+ __stdio_exit () {
+ __ofl_lock () {
+ } = 69504
+ }
+ }
+}
+```
+
+
+# Gas Metering
+
+```sh
+$ npm install -g wasm-metering
+
+$ wasm-meter hello.wasm hello-metered.wasm
+
+$ wasm3 hello-metered.wasm
+Warning: Gas is limited to 500000000.0000
+Hello, world!
+Gas used: 20.8950
+
+$ wasm3 --gas-limit 10 hello-metered.wasm
+Warning: Gas is limited to 10.0000
+Gas used: 10.0309
+Error: [trap] Out of gas
+```
+
+# Other resources
+
+- [WebAssembly by examples](https://wasmbyexample.dev/home.en-us.html) by Aaron Turner
+- [Writing WebAssembly](https://docs.wasmtime.dev/wasm.html) in Wasmtime docs
diff --git a/wasm3-sys/wasm3/docs/Demos.md b/wasm3-sys/wasm3/docs/Demos.md
new file mode 100644
index 0000000..1a19548
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Demos.md
@@ -0,0 +1,15 @@
+# Wasm3 demos
+
+- **In-browser Wasm3 (with MetaWASI support) on Webassembly.sh** │ [try it](https://webassembly.sh/?run-command=wasm3)
+- **PyGame + pywasm3 examples** | [github](https://github.com/wasm3/pywasm3/tree/main/examples)
+- **DOOM compiled to WASI, running on pywasm3** | [video](https://twitter.com/wasm3_engine/status/1393588527863144450), [github](https://github.com/wasm3/pywasm3-doom-demo)
+- **Wasm3 self-compilation using `clang.wasm`** | [github](https://github.com/wasm3/wasm3-self-compiling)
+- **Dino game**
+ - on PyBadge/Arduino | [video](https://twitter.com/vshymanskyy/status/1345048053041029121), [github](https://github.com/wasm3/wasm3-arduino/tree/main/examples/Wasm_Dino_PyBadge)
+ - on Raspberry Pi Pico | [github](https://github.com/vshymanskyy/wasm3_dino_rpi_pico)
+ - on ESP32 TTGO TDisplay | [github](https://github.com/wasm3/wasm3-arduino/tree/main/examples/Wasm_Dino_ESP32_TDisplay)
+- **Basic WiFi/Gpio access, updating `wasm` file over-the-air** │ [video](https://twitter.com/alvaroviebrantz/status/1221618910803513344), [github](https://github.com/alvarowolfx/wasm-arduino-wifi) [ESP32 / Web]
+- **RGB lamp animation using WebAssembly** │ [video](https://twitter.com/wasm3_engine/status/1222835097289752576), [github](https://github.com/vshymanskyy/Wasm3_RGB_Lamp) [nRF51 / nRF52 / ESP8266 / ESP32]
+- **LCD display rendering with AssemblyScript** │ [video](https://twitter.com/h1romas4/status/1228581467850100736), [github](https://github.com/h1romas4/m5stack-wasm3-testing) [M5Stack / ESP32]
+- **Conway's Game Of Life with AssemblyScript** │ [video](https://www.youtube.com/watch?v=Hc2sbhGMrig), [github](https://github.com/h1romas4/maixduino-wasm3-testing) [Maixduino / K210]
+
diff --git a/wasm3-sys/wasm3/docs/Development.md b/wasm3-sys/wasm3/docs/Development.md
new file mode 100644
index 0000000..0008221
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Development.md
@@ -0,0 +1,151 @@
+# Wasm3 development notes
+
+This project uses CMake.
+General build steps look like:
+```sh
+mkdir -p build
+cd build
+cmake ..
+make -j8
+```
+
+Wasm3 is continuously tested with Clang, GCC, MSVC compilers, and on multiple platforms.
+It can be easily integrated into any build system, as shown in `platforms`.
+
+## Build on Linux, OS X
+
+### Clang
+
+```sh
+mkdir build
+cd build
+cmake -GNinja -DCLANG_SUFFIX="-9" ..
+ninja
+```
+
+### GCC
+
+```sh
+mkdir build
+cd build
+cmake -GNinja ..
+ninja
+```
+
+## Build on Windows
+
+Prerequisites:
+- [Build Tools for Visual Studio 2019](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019)
+- [CMake](https://cmake.org/download/)
+- [Ninja](https://github.com/ninja-build/ninja/releases)
+- [Clang 9](https://releases.llvm.org/download.html#9.0.0)
+
+Recommended tools:
+- [Cmder](https://cmder.net/)
+- [Python3](https://www.python.org/downloads/)
+- [ptime](http://www.pc-tools.net/win32/ptime/)
+
+```sh
+# Prepare environment (if needed):
+"C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Auxiliary\Build\vcvars64.bat"
+set PATH=C:\Python36-32\;C:\Python36-32\Scripts\;%PATH%
+```
+
+### Build with MSBuild
+
+```sh
+# Create a build directory as usual, then build a specific configuration
+mkdir build
+cd build
+
+# Configure Clang, x64
+cmake -G"Visual Studio 16 2019" -A x64 -T ClangCL ..
+
+# Configure Clang, x86
+cmake -G"Visual Studio 16 2019" -A Win32 -T ClangCL ..
+
+# Configure MSVC, x64
+cmake -G"Visual Studio 16 2019" -A x64 ..
+
+# Configure MSVC, x86
+cmake -G"Visual Studio 16 2019" -A Win32 ..
+
+# Build
+cmake --build . --config Release
+cp ./Release/wasm3.exe ./
+```
+
+### Build with Ninja
+
+```sh
+set PATH=C:\Program Files\CMake\bin;%PATH%
+set PATH=C:\Program Files\LLVM\bin;%PATH%
+
+# Clang
+cmake -GNinja -DCLANG_CL=1 ..
+ninja
+
+# MSVC
+cmake -GNinja ..
+ninja
+```
+
+## Build using compiler directly
+
+This can be useful for cross-compilation, quick builds or when a build system (CMake, Ninja, etc.) is not available.
+
+### gcc/clang
+```sh
+gcc -O3 -g0 -s -Isource -Dd_m3HasWASI source/*.c platforms/app/main.c -lm -o wasm3
+```
+
+### msvc/clang-cl
+```sh
+cl source/*.c platforms/app/main.c /Isource /MD /Ox /Oy /Gw /GS- /W0 /Dd_m3HasWASI /Fewasm3.exe /link advapi32.lib
+```
+
+### mingw-w64
+```sh
+x86_64-w64-mingw32-gcc -O3 -g0 -s -Isource -Dd_m3HasWASI source/*.c platforms/app/main.c -lm -lpthread -static -o wasm3.exe
+```
+
+## Build for microcontrollers
+
+In `./platforms/` folder you can find projects for different targets. Some of them are using Platformio, so you can follow the regular pio build process. Others have custom instructions in respective `README.md` files.
+
+## Build with WasiEnv
+
+```sh
+wasimake cmake -GNinja ..
+ninja
+```
+
+If you want to enable experimental WASM features during the build:
+
+```sh
+export CFLAGS="-Xclang -target-feature -Xclang +tail-call"
+wasimake cmake -GNinja ..
+ninja
+```
+
+Here's how some options can be used with different tools:
+
+```log
+Clang target-feature option WABT option Chromium --js-flags option
+----------------------------------------------------------------------------------------------------------------
++multivalue --enable-multi-value --experimental-wasm-mv
++tail-call --enable-tail-call --experimental-wasm-return-call
++bulk-memory --enable-bulk-memory --experimental-wasm-bulk-memory
++nontrapping-fptoint --enable-saturating-float-to-int --experimental-wasm-sat-f2i-conversions
++sign-ext --enable-sign-extension --experimental-wasm-se
++simd128, +unimplemented-simd128 --enable-simd --experimental-wasm-simd
+```
+
+```sh
+# List clang options:
+llc -march=wasm32 -mattr=help
+
+# List Chromium options:
+chromium-browser --single-process --js-flags="--help" 2>&1 | grep wasm
+```
+
diff --git a/wasm3-sys/wasm3/docs/Diagnostics.md b/wasm3-sys/wasm3/docs/Diagnostics.md
new file mode 100644
index 0000000..5f9b947
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Diagnostics.md
@@ -0,0 +1,57 @@
+
+## Logs
+
+To enable various logs, modify the defines in `m3_config.h`. These are only enabled when compiled in debug mode.
+
+```C
+# define d_m3LogParse 0 // .wasm binary decoding info
+# define d_m3LogModule 0 // Wasm module info
+# define d_m3LogCompile 0 // wasm -> metacode generation phase
+# define d_m3LogWasmStack 0 // dump the wasm stack when pushed or popped
+# define d_m3LogEmit 0 // metacode-generation info
+# define d_m3LogCodePages 0 // dump metacode pages when released
+# define d_m3LogRuntime 0 // higher-level runtime information
+# define d_m3LogNativeStack 0 // track the memory usage of the C-stack
+```
+
+
+## Operation Profiling
+
+To profile the interpreter's operations enable `d_m3EnableOpProfiling` in `m3_config.h`. This profiling option works in either release or debug builds.
+
+When a runtime is released or `m3_PrintProfilerInfo ()` is called, a table of the executed operations and
+their instance counts will be printed to stderr.
+
+```
+ 23199904 op_SetSlot_i32
+ 12203917 op_i32_Add_ss
+ 6682992 op_u32_GreaterThan_sr
+ 2021555 op_u32_ShiftLeft_sr
+ 1136577 op_u32_ShiftLeft_ss
+ 1019725 op_CopySlot_32
+ 775431 op_i32_Subtract_ss
+ 703307 op_i32_Store_i32_rs
+ 337656 op_i32_Multiply_rs
+ 146383 op_u32_Or_rs
+ 99168 op_u64_Or_rs
+ 50311 op_u32_ShiftRight_rs
+ 43319 op_u32_ShiftLeft_rs
+ 21104 op_i64_Load_i64_s
+ 17450 op_i32_LessThan_sr
+ 7129 op_If_s
+ 5574 op_i32_Wrap_i64_r
+ 1630 op_f64_Load_f64_r
+ 1116 op_u32_Divide_sr
+ 903 op_i32_GreaterThan_ss
+ 390 op_u64_And_rs
+ 108 op_Select_f64_rss
+ 77 op_u64_ShiftLeft_sr
+ 64 op_Select_i32_ssr
+ 11 op_f64_Store_f64_ss
+ 10 op_MemGrow
+ 8 op_f64_GreaterThan_sr
+ 4 op_u64_LessThan_rs
+ 1 op_u32_Xor_ss
+ 1 op_i64_Subtract_ss
+```
+
diff --git a/wasm3-sys/wasm3/docs/Hardware.md b/wasm3-sys/wasm3/docs/Hardware.md
new file mode 100644
index 0000000..498224d
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Hardware.md
@@ -0,0 +1,60 @@
+# Wasm3 hardware support
+
+## Recommended devices (ideal for beginners)
+
+- ESP32-based
+ - **LilyGO TTGO T7 V1.4** │ [AliExpress](https://www.aliexpress.com/item/32977375539.html)
+ - **M5Stack Fire** │ [AliExpress](https://www.aliexpress.com/item/32847906756.html)
+- nRF52840-based
+ - **Adafruit CLUE** │ [Adafruit](https://www.adafruit.com/clue)
+ - **Arduino Nano 33 BLE (or BLE Sense)** │ [Arduino](https://store.arduino.cc/arduino-nano-33-ble)
+ - **Particle Argon** │ [Particle](https://store.particle.io/collections/bluetooth/products/argon)
+ - **Adafruit Feather nRF52840** | [Adafruit](https://www.adafruit.com/product/4062)
+- Other
+ - **Raspberry Pi Pico** | [Raspberry Pi](https://www.raspberrypi.org/products/raspberry-pi-pico)
+ - **Adafruit PyGamer/PyBadge/PyBadge LC** │ [Adafruit](https://www.adafruit.com/product/4242)
+ - **SparkFun Artemis** | [SparkFun](https://www.sparkfun.com/search/results?term=Artemis)
+ - **Teensy 4.0** │ [PJRC](https://www.pjrc.com/store/teensy40.html)
+ - **Wemos W600 PICO** │ [AliExpress](https://www.aliexpress.com/item/4000314757449.html)
+
+## Compatibility table
+
+Device | Chipset | Architecture | Clock | Flash | RAM
+--- |:---: | --- | -----:| --- | ---
+Espressif ESP32 | | Xtensa LX6 ⚠️ | 240MHz | 4 MB | 520KB
+Particle Argon, Boron, Xenon | nRF52840 | Cortex-M4F | 64MHz | 1 MB | 256KB
+Particle Photon, Electron | STM32F205 | Cortex-M3 | 120Mhz | 1 MB | 128KB
+Sparkfun Photon RedBoard | STM32F205 | Cortex-M3 | 120Mhz | 1 MB | 128KB
+Air602 | WM W600 | Cortex-M3 | 80MHz | 1 MB | 160KB+128KB
+Adafruit PyBadge | ATSAMD51J19 | Cortex-M4F | 120MHz | 512KB | 192KB
+Realtek RTL8711 | | Cortex-M3 | 166MHz | 2 MB | 2 MB+512KB
+Nordic nRF52840 | | Cortex-M4F | 64MHz | 1 MB | 256KB
+Nordic nRF52833 | | Cortex-M4F | 64MHz | 512KB | 128KB
+P-Nucleo WB55RG | STM32WB55RG | Cortex-M4F | 64MHz | 1 MB | 256KB
+Teensy 4.0 | NXP iMXRT1062 | Cortex-M7 | 600MHz | 2 MB | 1 MB
+Teensy 3.5 | MK64FX512 | Cortex-M4F | 120MHz | 512KB | 192KB
+MXChip AZ3166 | EMW3166 | Cortex-M4 | 100MHz | 1 MB+2 MB | 256KB
+Arduino Due | AT91SAM3X8E | Cortex-M3 | 84MHz | 512KB | 96KB
+Sipeed MAIX | Kendryte K210 | RV64IMAFDC | 400MHz | 16 MB | 8 MB
+Fomu (soft CPU) | Lattice ICE40UP5K | RV32I | 12MHz | 2 MB | 128KB
+
+## Limited support
+
+The following devices can run Wasm3, however they cannot afford to allocate even a single Linear Memory page (64KB).
+This means `memoryLimit` should be set to the actual amount of RAM available, and that in turn usually breaks the allocator of the hosted Wasm application (which still assumes the page is 64KB and performs OOB access).
+
+Device | Chipset | Architecture | Clock | Flash | RAM
+--- |:---: | --- | -----:| --- | ---
+Espressif ESP8266 | | Xtensa L106 ⚠️ | 160MHz | 4 MB | ~50KB (available)
+Teensy 3.1/3.2 | NXP MK20DX256 | Cortex-M4 | 72MHz | 288KB | 64KB
+Blue Pill | STM32F103 | Cortex-M3 | 72MHz | 64KB | 20KB
+Arduino MKR* | SAMD21 | Cortex-M0+ ⚠️ | 48MHz | 256KB | 32KB
+Arduino 101 | Intel Curie | ARC32 | 32MHz | 196KB | 24KB
+SiFive HiFive1 | Freedom E310 | RV32IMAC | 320MHz | 16 MB | 16KB
+Nordic nRF52832 | | Cortex-M4F | 64MHz | 256/512KB | 32/64KB
+Nordic nRF51822 | | Cortex-M0 ⚠️ | 16MHz | 128/256KB | 16/32KB
+Wicked Device WildFire | ATmega1284 | 8-bit AVR ⚠️ | 20MHz | 128KB | 16KB
+
+### Legend:
+ ⚠️ This architecture/compiler currently fails to perform TCO (Tail Call Optimization/Elimination), which leads to sub-optimal interpreter behaviour (intense native stack usage, lower performance).
+There are plans to improve this in future 🦄.
diff --git a/wasm3-sys/wasm3/docs/Installation.md b/wasm3-sys/wasm3/docs/Installation.md
new file mode 100644
index 0000000..651cdf3
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Installation.md
@@ -0,0 +1,26 @@
+# Wasm3 installation
+
+## Windows
+Download `wasm3-win-x64.exe` or `wasm3-win-x86.exe` from the [latest release page](https://github.com/wasm3/wasm3/releases/latest).
+
+## macOS
+Use [Homebrew](https://brew.sh) to build and install automatically:
+```sh
+brew install wasm3
+```
+
+## Cosmopolitan / Actually Portable Executable
+[APE](https://justine.lol/cosmopolitan/index.html) is a polyglot format that runs natively on Linux + Mac + Windows + FreeBSD + OpenBSD + NetBSD + BIOS.
+Download `wasm3-cosmopolitan.com` from the [latest release page](https://github.com/wasm3/wasm3/releases/latest)
+
+## OpenWRT
+Follow instructions [here](https://github.com/wasm3/wasm3-openwrt-packages).
+
+## Arduino / PlatformIO / Particle.io library
+Find `Wasm3` in the `Library Manager` and install it.
+
+## Python module
+```sh
+pip3 install pywasm3
+```
+
diff --git a/wasm3-sys/wasm3/docs/Interpreter.md b/wasm3-sys/wasm3/docs/Interpreter.md
new file mode 100644
index 0000000..67f2688
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Interpreter.md
@@ -0,0 +1,166 @@
+# M3
+
+This is a WebAssembly interpreter written in C using a novel, high performance interpreter topology. The interpreter strategy (named M3) was developed prior to this particular Wasm project and is described some below.
+
+## Purpose
+
+I don't know. I just woke up one day and started hacking this out after realizing my interpreter was well suited for the Wasm bytecode structure. Some ideas:
+
+* It could be useful for embedded systems.
+* It might be a good start-up, pre-JIT interpreter in a more complex Wasm compiler system.
+* It could serve as a Wasm validation library.
+* The interpreter topology might be inspiring to others.
+
+
+## Benchmarks
+
+It's at least fleshed out enough to run some simple benchmarks.
+
+Tested on a 4 GHz Intel Core i7 iMac (Retina 5K, 27-inch, Late 2014). M3 was compiled with Clang -Os. C benchmarks were compiled with gcc with -O3
+
+### Mandelbrot
+
+C code lifted from: https://github.com/ColinEberhardt/wasm-mandelbrot
+
+|Interpreter|Execution Time|Relative to GCC| |
+|-----------|--------------|---------------|----|
+|Life |547 s |133 x | https://github.com/perlin-network/life
+|Lua |122 s |30 x | This isn't Lua running some weird Wasm transcoding; a manual Lua conversion of the C benchmark as an additional reference point.
+|M3 |17.9 s |4.4 x | (3.7 x on my 2016 MacBook Pro)
+|GCC |4.1 s | |
+
+### CRC32
+
+|Interpreter|Execution Time|Relative to GCC|
+|-----------|--------------|---------------|
+|Life |153 s |254 x |
+|M3 |5.1 s |8.5 x |
+|GCC |600 ms | |
+
+
+In general, the M3 strategy seems capable of executing code around 4-15X slower than compiled code on a modern x86 processor. (Older CPUs don't fare as well. I suspect branch predictor differences.) I have yet to test on anything ARM.
+
+## M3: Massey Meta Machine
+
+Over the years, I've mucked around with creating my own personal programming language. It's called Gestalt. The yet unreleased repository will be here: https://github.com/soundandform/gestalt
+
+Early on I decided I needed an efficient interpreter to achieve the instant-feedback, live-coding environment I desire. Deep traditional compilation is too slow and totally unnecessary during development. And, most importantly, compilation latency destroys creative flow.
+
+I briefly considered retooling something extant. The Lua virtual machine, one of the faster interpreters, is too Lua centric. And everything else is too slow.
+
+I've also always felt that the "spin in a loop around a giant switch statement" thing most interpreters do was clumsy and boring. My intuition said there was something more elegant to be found.
+
+The structure that emerged I named a "meta machine" since it mirrors the execution of compiled code much more closely than the switch-based virtual machine.
+
+I set out with a goal of approximating Lua's performance. But this interpreter appears to beat Lua by 3X and more on basic benchmarks -- whatever they're worth!
+
+### How it works
+
+This rough information might not be immediately intelligible without referencing the source code.
+
+#### Reduce bytecode decoding overhead
+
+* Bytecode/opcodes are translated into more efficient "operations" during a compilation pass, generating pages of meta-machine code
+ * M3 trades some space for time. Opcodes map to up to 3 different operations depending on the number of source operands and commutative-ness.
+* Commonly occurring sequences of operations can can also be optimized into a "fused" operation. This *sometimes* results in improved performance.
+ * the modern CPU pipeline is a mysterious beast
+* In M3/Wasm, the stack machine model is translated into a more direct and efficient "register file" approach.
+
+#### Tightly Chained Operations
+
+* M3 operations are C functions with a single, fixed function signature.
+
+ ```C
+ void * Operation_Whatever (pc_t pc, u64 * sp, u8 * mem, reg_t r0, f64 fp0);
+ ```
+
+* The arguments of the operation are the M3's virtual machine registers
+ * program counter, stack pointer, etc.
+* The return argument is a trap/exception and program flow control signal
+* The M3 program code is traversed by each operation calling the next. The operations themselves drive execution forward. There is no outer control structure.
+ * Because operations end with a call to the next function, the C compiler will tail-call optimize most operations.
+* Finally, note that x86/ARM calling conventions pass initial arguments through registers, and the indirect jumps between operations are branch predicted.
+
+#### The End Result
+
+Since operations all have a standardized signature and arguments are tail-call passed through to the next, the M3 "virtual" machine registers end up mapping directly to real CPU registers. It's not virtual! Instead, it's a meta machine with very low execution impedance.
+
+|M3 Register |x86 Register|
+|-----------------------------|------------|
+|program counter (pc) |rdi |
+|stack pointer (sp) |rsi |
+|linear memory (mem) |rdx |
+|integer register (r0) |rcx |
+|floating-point register (fp0)|xmm0 |
+
+
+For example, here's a bitwise-or operation in the M3 compiled on x86.
+
+```assembly
+m3`op_u64_Or_sr:
+ 0x1000062c0 <+0>: movslq (%rdi), %rax ; load operand stack offset
+ 0x1000062c3 <+3>: orq (%rsi,%rax,8), %rcx ; or r0 with stack operand
+ 0x1000062c7 <+7>: movq 0x8(%rdi), %rax ; fetch next operation
+ 0x1000062cb <+11>: addq $0x10, %rdi ; increment program counter
+ 0x1000062cf <+15>: jmpq *%rax ; jump to next operation
+```
+
+
+#### Registers and Operational Complexity
+
+* The conventional Windows calling convention isn't compatible with M3, as-is, since it only passes 4 arguments through registers. Applying the vectorcall calling convention (https://docs.microsoft.com/en-us/cpp/cpp/vectorcall) resolves this problem.
+
+* It's possible to use more CPU registers. For example, adding an additional floating-point register to the meta-machine did marginally increase performance in prior tests. However, the operation space increases exponentially. With one register, there are up to 3 operations per opcode (e.g. a non-commutative math operation). Adding another register increases the operation count to 10. However, as you can see above, operations tend to be tiny.
+
+#### Stack Usage
+
+* Looking at the above assembly code, you'll notice that once an M3 operation is optimized, it doesn't need the regular stack (no mucking with the ebp/esp registers). This is the case for 90% of the opcodes. Branching and call operations do require stack variables. Therefore, execution can't march forward indefinitely; the stack would eventually overflow.
+
+ Therefore, loops unwind the stack. When a loop is continued, the Continue operation returns, unwinding the stack. Its return value is a pointer to the loop opcode it wants to unwind to. The Loop operations checks for its pointer and responds appropriately, either calling back into the loop code or returning the loop pointer back down the call stack.
+
+* Traps/Exceptions work similarly. A trap pointer is returned from the trap operation which has the effect of unwinding the entire stack.
+
+* Returning from a Wasm function also unwinds the stack, back to the point of the Call operation.
+
+* But, because M3 execution leans heavily on the native stack, this does create one runtime usage issue.
+
+ A conventional interpreter can save its state, break out of its processing loop and return program control to the client code. This is not the case in M3 since the C stack might be wound up in a loop for long periods of time.
+
+ With Gestalt, I resolved this problem with fibers (built with Boost Context). M3 execution occurs in a fiber so that control can effortlessly switch to the "main" fiber. No explicit saving of state is necessary since that's the whole purpose of a fiber.
+
+ More simplistically, the interpreter runtime can also periodically call back to the client (in the either the Loop or LoopContinue operation). This is necessary, regardless, to detect hangs and break out of infinite loops.
+
+
+## The M3 strategy for other languages (is rad)
+
+The Gestalt M3 interpreter works slightly differently than this Wasm version. With Gestalt, blocks of all kind (if/else/try), not just loops, unwind the native stack. (This somewhat degrades raw x86 performance.)
+
+But, this adds a really beautiful property to the interpreter. The lexical scoping of a block in the language source code maps directly into the interpreter. All opcodes/operations end up having an optional prologue/epilogue structure. This made things like reference-counting objects in Gestalt effortless. Without this property, the compiler itself would have to track scope and insert dererence opcodes intentionally. Instead, the "CreateObject" operation is also the "DestroyObject" operation on the exit/return pathway.
+
+Here's some pseudocode to make this more concrete:
+
+```
+return_t Operation_NewObject (registers...)
+{
+ Object o = runtime->CreateObject (registers...);
+
+ * stack [index] = o;
+
+ return_t r = CallNextOperation (registers...); // executes to the end of the scope/block/curly-brace & returns
+
+ if (o->ReferenceCount () == 0)
+ runtime->DestroyObject (registers..., o); // calls o's destructor and frees memory
+
+ return r;
+}
+```
+
+Likewise, a "defer" function (like in Go) becomes absolutely effortless to implement. Exceptions (try/catch) as well.
+
+
+## Prior Art
+
+After the Wasm3 project was posted to Hacker News (https://news.ycombinator.com/item?id=22024758), I finally discovered precedent for this tail-call interpreter design. It has previously been called "threaded code". See the "Continuation-passing style" section: http://www.complang.tuwien.ac.at/forth/threaded-code.html).
+
+If this style of interpreter was discussed back in the 70's, why hasn't it been more popular? I suspect because there was no benefit until more recently. Older calling conventions only used the stack to pass arguments, older CPUs didn't have branch prediction and compiler tail-call optimization maybe weren't ubiqutous.
+
diff --git a/wasm3-sys/wasm3/docs/Performance.md b/wasm3-sys/wasm3/docs/Performance.md
new file mode 100644
index 0000000..4b52a74
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Performance.md
@@ -0,0 +1,91 @@
+# Performance
+
+## CoreMark 1.0 results
+
+```log
+# Intel i5-8250U x64 (1.6-3.4GHz)
+
+Node v13.0.1 (interpreter) 28.544923 57.0x
+wac (wax) 101.864113 16.0x
+wasm-micro-runtime 201.612903 8.1x ▲ slower
+wasm3 1627.869119 1.0
+Wasmer 0.13.1 singlepass 4065.591544 2.5x ▼ faster
+wasmtime 0.8.0 (--optimize) 6453.505427 4.0x
+Wasmer 0.13.1 cranelift 6467.164442 4.0x
+Webassembly.sh (Chromium 78) 6914.325225 4.2x
+Webassembly.sh (Firefox 70) 7251.153593 4.5x
+wasmer-js (Node v13.0.1) 10043.827611 6.2x
+Wasmer 0.13.1 llvm 12450.199203 7.6x
+WAVM 14946.566026 9.2x
+Native (GCC 7.4.0, 32-bit) 18070.112035 11.1x
+Native (GCC 7.4.0, 64-bit) 19144.862795 11.8x
+```
+
+**Note:** Here is more info on [how to run CoreMark benchmark](https://github.com/wasm3/wasm-coremark).
+
+## Simple recursive Fibonacci calculation test
+
+```log
+ fib(40)
+-----------------------------------------------------------------------------------------
+# Intel i5-8250U x64 (1.6-3.4GHz)
+Native C implementation 0.23s
+Linux 3.83s
+Win 10 5.35s
+wasm3 on V8 (Emscripten 1.38, node v13.0.1) 17.98s
+
+# Raspberry Pi 4 BCM2711B0 armv7l (A72 @ 1.5GHz)
+Native C implementation 1.11s
+Linux 22.97s
+
+# Orange Pi Zero Plus2 H5 aarch64 (A53 @ 1GHz)
+Native C implementation 2.55s
+Linux 50.00s
+
+# VoCore2 mips32r2 (MT7628AN @ 580MHz)
+Native C implementation 6.21s
+OpenWRT 2m 38s
+
+# Xiaomi Mi Router 3G mips32r2 (MT7621AT @ 880MHz)
+Native C implementation 8.83s
+OpenWRT 3m 20s
+```
+
+## Wasm3 on MCUs
+
+```log
+ fib(24) comments
+-----------------------------------------------------------------------------------------
+Maix (K210) rv64imafc @ 400MHz 77ms
+ESP8266 LX106 @ 160MHz 308ms TCO failed, stack used: 9024
+ESP32 LX6 @ 240MHz 297ms TCO failed, stack used: 10600
+ESP32-s2 (beta) LX6 @ 240MHz 297ms TCO failed
+Particle Photon Arm M3 @ 120MHz 536ms
+MXChip AZ3166 Arm M4 @ 100MHz ms
+WM W600 Arm M3 @ 80MHz 698ms TCO enabled, stack used: 1325
+WM W600 Arm M3 @ 80MHz 826ms TCO disabled, stack used: 8109
+Arduino DUE (SAM3X8E) Arm M3 @ 84MHz 754ms
+BleNano2 (nRF52) Arm M4 @ 64MHz 1.19s
+Arduino MKR1000 Arm M0+ @ 48MHz 1.93s TCO failed
+TinyBLE (nRF51) Arm M0 @ 16MHz 5.69s TCO failed
+BluePill Arm M3 @ 72MHz 7.62s
+HiFive1 (FE310) rv32imac @ 320MHz 9.10s <- something wrong here?
+ATmega1284 avr @ 16MHz 12.99s TCO failed
+Fomu rv32i @ 12MHz 25.20s
+```
+
+## Wasm3 vs other languages
+
+```log
+ fib(40)
+-----------------------------------------------------------------------------------------
+LuaJIT jit 1.15s
+Node v10.15 jit 2.97s ▲ faster
+Wasm3 interp 3.83s
+Lua 5.1 interp 16.65s ▼ slower
+Python 2.7 interp 34.08s
+Python 3.4 interp 35.67s
+Micropython v1.11 interp 85,00s
+Espruino 2v04 interp >20m
+```
+
diff --git a/wasm3-sys/wasm3/docs/Testing.md b/wasm3-sys/wasm3/docs/Testing.md
new file mode 100644
index 0000000..b38820c
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Testing.md
@@ -0,0 +1,61 @@
+# Wasm3 tests
+
+## Running WebAssembly spec tests
+
+To run spec tests, you need `python3`
+
+```sh
+# In test directory:
+python3 ./run-spec-test.py
+```
+
+It will automatically download, extract, run the WebAssembly core test suite.
+
+## Running WASI test
+
+Wasm3 comes with a set of benchmarks and test programs (prebuilt as `WASI` apps) including `CoreMark`, `C-Ray`, `Brotli`, `mandelbrot`, `smallpt` and `wasm3` itself.
+
+This test will run all of them and verify the output:
+
+```sh
+# In test directory:
+python3 ./run-wasi-test.py
+```
+
+It can be run against other engines as well:
+
+```sh
+./run-wasi-test.py --exec wasmtime # [PASS]
+./run-wasi-test.py --exec "wavm run" # [PASS]
+./run-wasi-test.py --exec "wasmer run" # [PASS]
+./run-wasi-test.py --exec "wasmer-js run" # [PASS]
+./run-wasi-test.py --exec $WAMR/iwasm --timeout=300 # [PASS, but very slow]
+./run-wasi-test.py --exec $WAC/wax --timeout=300 # [FAIL, crashes on most tests]
+```
+
+## Running coverage-guided fuzz testing with libFuzzer
+
+You need to produce a fuzzer build first (use your version of Clang):
+
+```sh
+# In wasm3 root:
+mkdir build-fuzzer
+cd build-fuzzer
+cmake -GNinja -DCLANG_SUFFIX="-9" ..
+cmake -DBUILD_FUZZ:BOOL=TRUE ..
+ninja
+```
+
+```sh
+# In test directory:
+../build-fuzzer/wasm3-fuzzer -detect_leaks=0 ./fuzz/corpus
+```
+
+Read [more on libFuzzer](https://llvm.org/docs/LibFuzzer.html) and it's options.
+
+Note: to catch fuzzer errors in debugger, you need to define:
+```sh
+export ASAN_OPTIONS=abort_on_error=1
+export UBSAN_OPTIONS=abort_on_error=1
+```
+
diff --git a/wasm3-sys/wasm3/docs/Troubleshooting.md b/wasm3-sys/wasm3/docs/Troubleshooting.md
new file mode 100644
index 0000000..9b95b12
--- /dev/null
+++ b/wasm3-sys/wasm3/docs/Troubleshooting.md
@@ -0,0 +1,26 @@
+# Wasm3 troubleshooting
+
+### `Error: [trap] stack overflow`
+
+Increase the stack size:
+```sh
+wasm3 --stack-size 1000000 file.wasm
+```
+
+### `Error: missing imported function`
+
+This means that the runtime doesn't provide a specific function, needed for your module execution.
+You need to implement the required functions, and re-build Wasm3.
+Alternatively, you can use Python to define your environment. Check out [`pywasm3`](https://pypi.org/project/pywasm3/) module.
+
+**Note:** If this happens with `WASI` functions like `wasi_unstable.*` or `wasi_snapshot_preview1.*`, please report as a bug.
+
+### `Error: compiling function overran its stack height limit`
+
+Try increasing `d_m3MaxFunctionStackHeight` in `m3_config.h` and rebuilding Wasm3.
+
+### `Error: [Fatal] repl_load: unallocated linear memory`
+
+Your module requires some `Memory`, but doesn't define/export it by itself.
+This happens if module is built by `Emscripten`, or it's a library that is intended to be linked to some other modules.
+Wasm3 currently doesn't support running such modules directly, but you can remove this limitation when embedding Wasm3 into your own app.
diff --git a/wasm3-sys/wasm3/extra/blynk.png b/wasm3-sys/wasm3/extra/blynk.png
new file mode 100644
index 0000000..000fde8
Binary files /dev/null and b/wasm3-sys/wasm3/extra/blynk.png differ
diff --git a/wasm3-sys/wasm3/extra/button.png b/wasm3-sys/wasm3/extra/button.png
new file mode 100644
index 0000000..85bceaf
Binary files /dev/null and b/wasm3-sys/wasm3/extra/button.png differ
diff --git a/wasm3-sys/wasm3/extra/disasm-func.sh b/wasm3-sys/wasm3/extra/disasm-func.sh
new file mode 100755
index 0000000..188f3ff
--- /dev/null
+++ b/wasm3-sys/wasm3/extra/disasm-func.sh
@@ -0,0 +1,17 @@
+#
+# Utility to disassemble a specific function.
+# Usage:
+# ./disasm-func.sh ../build/wasm3 i32_Divide_sr
+#
+
+FILE="$1"
+FUNC="$2"
+
+# get starting address and size of function fact from nm
+ADDR=$(nm --print-size --radix=d $FILE | grep $FUNC | cut -d ' ' -f 1,2)
+# strip leading 0's to avoid being interpreted by objdump as octal addresses
+STARTADDR=$(echo $ADDR | cut -d ' ' -f 1 | sed 's/^0*\(.\)/\1/')
+SIZE=$(echo $ADDR | cut -d ' ' -f 2 | sed 's/^0*//')
+STOPADDR=$(( $STARTADDR + $SIZE ))
+
+objdump --disassemble $FILE --start-address=$STARTADDR --stop-address=$STOPADDR -M suffix
diff --git a/wasm3-sys/wasm3/extra/iden3.svg b/wasm3-sys/wasm3/extra/iden3.svg
new file mode 100644
index 0000000..975144f
--- /dev/null
+++ b/wasm3-sys/wasm3/extra/iden3.svg
@@ -0,0 +1,202 @@
+
\ No newline at end of file
diff --git a/wasm3-sys/wasm3/extra/logo.png b/wasm3-sys/wasm3/extra/logo.png
new file mode 100644
index 0000000..c1cf38d
Binary files /dev/null and b/wasm3-sys/wasm3/extra/logo.png differ
diff --git a/wasm3-sys/wasm3/extra/scailable.png b/wasm3-sys/wasm3/extra/scailable.png
new file mode 100644
index 0000000..eb997b8
Binary files /dev/null and b/wasm3-sys/wasm3/extra/scailable.png differ
diff --git a/wasm3-sys/wasm3/extra/screenshot-android.png b/wasm3-sys/wasm3/extra/screenshot-android.png
new file mode 100644
index 0000000..885bbdd
Binary files /dev/null and b/wasm3-sys/wasm3/extra/screenshot-android.png differ
diff --git a/wasm3-sys/wasm3/extra/screenshot-ios.png b/wasm3-sys/wasm3/extra/screenshot-ios.png
new file mode 100644
index 0000000..8bfe5b4
Binary files /dev/null and b/wasm3-sys/wasm3/extra/screenshot-ios.png differ
diff --git a/wasm3-sys/wasm3/extra/shareup_app.svg b/wasm3-sys/wasm3/extra/shareup_app.svg
new file mode 100644
index 0000000..875a8b1
--- /dev/null
+++ b/wasm3-sys/wasm3/extra/shareup_app.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/wasm3-sys/wasm3/extra/testutils.py b/wasm3-sys/wasm3/extra/testutils.py
new file mode 100755
index 0000000..97eccc6
--- /dev/null
+++ b/wasm3-sys/wasm3/extra/testutils.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+# Author: Volodymyr Shymanskyy
+
+import os
+import re, fnmatch
+import pathlib
+
+class ansi:
+ ENDC = '\033[0m'
+ HEADER = '\033[94m'
+ OKGREEN = '\033[92m'
+ WARNING = '\033[93m'
+ FAIL = '\033[91m'
+ BOLD = '\033[1m'
+ UNDERLINE = '\033[4m'
+
+class dotdict(dict):
+ def __init__(self, *args, **kwargs):
+ super(dotdict, self).__init__(*args, **kwargs)
+ for arg in args:
+ if isinstance(arg, dict):
+ for k, v in arg.items():
+ self[k] = v
+ if kwargs:
+ for k, v in kwargs.items():
+ self[k] = v
+
+ __getattr__ = dict.get
+ __setattr__ = dict.__setitem__
+ __delattr__ = dict.__delitem__
+
+class Blacklist():
+ def __init__(self, patterns):
+ self._patterns = list(map(fnmatch.translate, patterns))
+ self.update()
+
+ def add(self, patterns):
+ self._patterns += list(map(fnmatch.translate, patterns))
+ self.update()
+
+ def update(self):
+ self._regex = re.compile('|'.join(self._patterns))
+
+ def __contains__(self, item):
+ return self._regex.match(item) is not None
+
+def filename(p):
+ _, fn = os.path.split(p)
+ return fn
+
+def pathname(p):
+ pn, _ = os.path.split(p)
+ return pn
+
+def ensure_path(p):
+ pathlib.Path(p).mkdir(parents=True, exist_ok=True)
diff --git a/wasm3-sys/wasm3/extra/txiki_js.png b/wasm3-sys/wasm3/extra/txiki_js.png
new file mode 100644
index 0000000..45cdb91
Binary files /dev/null and b/wasm3-sys/wasm3/extra/txiki_js.png differ
diff --git a/wasm3-sys/wasm3/extra/utils.mk b/wasm3-sys/wasm3/extra/utils.mk
new file mode 100644
index 0000000..f5ce9ea
--- /dev/null
+++ b/wasm3-sys/wasm3/extra/utils.mk
@@ -0,0 +1,39 @@
+.PHONY: format
+
+all:
+
+format:
+ # Convert tabs to spaces
+ find ./source -type f -iname '*.[cpp\|c\|h]' -exec bash -c 'expand -t 4 "$$0" | sponge "$$0"' {} \;
+ # Remove trailing whitespaces
+ find ./source -type f -iname '*.[cpp\|c\|h]' -exec sed -i 's/ *$$//' {} \;
+
+preprocess: preprocess_restore
+ cp ./source/m3_exec.h ./source/m3_exec.h.bak
+ cp ./source/m3_compile.c ./source/m3_compile.c.bak
+ awk 'BEGIN {RS=""}{gsub(/\\\n/,"\\\n__NL__ ")}1' ./source/m3_exec.h | sponge ./source/m3_exec.h
+ cpp -I./source -P ./source/m3_compile.c | sponge ./source/m3_compile.c
+ awk '{gsub(/__NL__/,"\n")}1' ./source/m3_compile.c | sponge ./source/m3_compile.c
+ mv ./source/m3_exec.h.bak ./source/m3_exec.h
+
+preprocess_restore:
+ -mv source/m3_compile.c.bak source/m3_compile.c
+ touch source/m3_compile.c
+
+
+test_rv64:
+ riscv64-linux-gnu-gcc -DDEBUG -Dd_m3HasWASI \
+ -I./source ./source/*.c ./platforms/app/main.c \
+ -O3 -g0 -flto -lm -static \
+ -o wasm3-rv64
+
+ cd test; python3 run-wasi-test.py --fast --exec "qemu-riscv64-static ../wasm3-rv64"
+ rm ./wasm3-rv64
+
+test_cpp:
+ clang -xc++ -Dd_m3HasWASI \
+ -I./source ./source/*.c ./platforms/app/main.c \
+ -O3 -g0 -flto -lm -static \
+ -o wasm3-cpp
+ cd test; python3 run-wasi-test.py --fast --exec "../wasm3-cpp"
+ rm ./wasm3-cpp
diff --git a/wasm3-sys/wasm3/extra/wapm-package/README.md b/wasm3-sys/wasm3/extra/wapm-package/README.md
new file mode 100644
index 0000000..0174c86
--- /dev/null
+++ b/wasm3-sys/wasm3/extra/wapm-package/README.md
@@ -0,0 +1,105 @@
+# Wasm3
+
+[Wasm3](https://github.com/wasm3/wasm3) is the fastest WebAssembly interpreter, and the most universal runtime.
+It's packaged into a `WebAssembly` package, so you can finally run `WebAssembly` on `WebAssembly` 😆
+
+## Running on WebAssembly.sh
+
+Open [**WebAssembly.sh**](https://webassembly.sh)
+
+First you need to fetch a wasm file you'd like to run:
+
+```sh
+$ curl https://raw.githubusercontent.com/wasm3/wasm3/main/test/lang/fib32.wasm -o /tmp/fib32.wasm
+
+$ ls -l /tmp/fib32.wasm
+---------- 1 somebody somegroup 62 1970-01-19 05:45 /tmp/fib32.wasm
+```
+
+Now we can run `wasm3` in interactive mode:
+
+```sh
+$ wasm3 --repl /tmp/fib32.wasm
+wasm3> fib 20
+Result: 6765
+wasm3> fib 30
+Result: 832040
+wasm3> ^C
+$
+```
+
+Or run a specific function directly:
+
+```sh
+$ wasm3 --func fib /tmp/fib32.wasm 30
+Result: 832040
+```
+
+`wasm3` also supports `WASI`, so you can run:
+
+```sh
+$ curl https://raw.githubusercontent.com/wasm3/wasm3/main/test/wasi/simple/test.wasm -o /tmp/test.wasm
+$ wasm3 /tmp/test.wasm
+```
+
+or even... run wasm3 inside wasm3:
+
+```sh
+$ curl https://registry-cdn.wapm.io/contents/vshymanskyy/wasm3/0.5.0/build/wasm3-wasi.wasm -o /tmp/wasm3.wasm
+$ wasm3 --stack-size 100000 /tmp/wasm3.wasm /tmp/test.wasm
+```
+
+## Tracing
+
+You can also get structured traces of arbitrary WASM file execution (and this requires no specific support from the runtime):
+
+```sh
+$ wasm3-strace --repl /tmp/fib32.wasm
+wasm3> fib 3
+fib (i32: 3) {
+ fib (i32: 1) {
+ } = 1
+ fib (i32: 2) {
+ fib (i32: 0) {
+ } = 0
+ fib (i32: 1) {
+ } = 1
+ } = 1
+} = 2
+Result: 2
+```
+
+WASI apps tracing is also supported:
+
+```sh
+$ wasm3-strace /tmp/test.wasm trap
+_start () {
+ __wasm_call_ctors () {
+ __wasilibc_populate_preopens () {
+ wasi_snapshot_preview1!fd_prestat_get(3, 65528) { Click to expand!
+ +```js + } = 131072 + } = 131088 + } = 131088 + calloc (i32: 24, i32: 0) { + dlmalloc (i32: 96) { + } = 131120 + memset (i32: 131120, i32: 65504, i32: 0) { + } = 131120 + } = 131120 + po_map_assertvalid (i32: 131088) { + } + po_map_assertvalid (i32: 131088) { + } + } + wasi_unstable!fd_prestat_get(3, 65528) {
+ Wasm3 running on iPhone 8
+