TinyGo Compiler

Partial evaluation is used to transform initialization functions into constant globals. This is necessary because:

• LLVM Optimization: LLVM optimizes globals with initializers much more effectively than initialization code.
• Dead Code Elimination: Dead globals are easier to optimize away.
• Constant Detection: It allows the compiler to detect constant globals, which enables better propagation and dead code elimination during branching.
• Resource Efficiency: On microcontrollers, constants can be stored in Flash memory instead of consuming precious RAM.

TinyGo supports two primary patterns for WebAssembly development:

1. Explicit Exports: Define and export specific functions to JavaScript using the //export <name> directive. You can also specify a custom Wasm module name (defaulting to env) using //go:wasm-module <module>.
2. Main Function: Define a func main() which executes similarly to the standard Go implementation. This is typically used for standalone logic that runs upon instantiation.

Browsers require WebAssembly files to be served with the Content-Type: application/wasm HTTP header. If this header is missing, the module will fail to run.

When building a local server in Go to serve your Wasm files, ensure you intercept .wasm requests to set this header.

package main

import (
	"log"
	"net/http"
	"strings"
)

const dir = "./html"

func main() {
	fs := http.FileServer(http.Dir(dir))
	log.Print("Serving " + dir + " on http://localhost:8080")
	http.ListenAndServe(":8080", http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
		resp.Header().Add("Cache-Control", "no-cache")
		if strings.HasSuffix(req.URL.Path, ".wasm") {
			resp.Header().Set("content-type", "application/wasm")
		}
		fs.ServeHTTP(resp, req)
	}))
}

To compile a Go file into a WebAssembly module, use the tinygo build command with the -target wasm flag.

Example command to build a module named wasm.wasm from a specific Go file:

tinygo build -o ./wasm.wasm -target wasm ./main/main.go

TinyGo supports compiling for both browser-based WebAssembly (WASM) and server-side/edge WebAssembly System Interface (WASI) runtimes like Fastly Compute, Fermyon Spin, and wazero.

To compile a program for a WASI Preview 1 runtime, use the tinygo build command with -buildmode=c-shared, -o for the output filename, and -target=wasip1.

Alternatively, you can use Go 1.24+ style environment variables (GOOS and GOARCH) to specify the target.

tinygo build -buildmode=c-shared -o add.wasm -target=wasip1 add.go

This directory contains custom commands designed to be executed during specific Docker Hub build phases. To implement these, you must configure your Docker Hub build settings to trigger these scripts at the appropriate lifecycle stages. For detailed instructions on how to configure and use custom build phase hooks, refer to the official Docker documentation.

https://docs.docker.com/docker-hub/builds/advanced/#custom-build-phase-hooks

TinyGo can compile Go programs for over 150 different microcontroller boards. To compile and flash a program directly to a supported board, use the tinygo flash command with the -target flag specifying your board name.

Example of flashing an Arduino Uno:

tinygo flash -target arduino-uno examples/blinky1