Programming WebAssembly with Rust (Kevin Hoffman) (Z-Library)

【One-Line Pitch】 A hands-on guide to WebAssembly that starts with raw bytecode and ends with Rust-powered modules running in browsers, on Raspberry Pis, and inside a multiplayer game engine. Best for developers who want to understand what happens beneath the tooling before they trust it. 【Book Arc】 - **Opening (~0%–10%)**: Frames WebAssembly as a portable, type-safe compilation target rather than a JavaScript replacement or a Flash successor, and clarifies what it is not. - **Early (~10%–35%)**: Teaches the low-level stack machine, the text format (wast/wat), and the wabt toolchain, then builds a hand-written checkers module to internalize memory, globals, and control flow. - **Middle (~35%–55%)**: Moves into Rust, compiles a first module, and rebuilds checkers in Rust with iterators, structs, and cleaner move-generation logic. - **Late (~55%–80%)**: Covers JavaScript interop patterns and begins exploring non-browser hosts, including embedded and IoT scenarios. - **Ending (~80%–100%)**: Culminates in a multiplayer arena game engine where developers upload WebAssembly combat modules, plus a Raspberry Pi lighting-control project. 【Key Takeaways】 - **WebAssembly is a portable compilation target, not a language or a JS transpile target** (Opening): it runs anywhere a host exists, which is why the book pushes beyond browser-only thinking. - **Understanding the stack machine and raw wat pays off later** (Early): hand-writing checkers forces you to confront linear memory, bit-packed state, and type-safe control flow before compilers hide them. - **Bit flags and idempotent operations matter in constrained memory** (Early): using `i32.or` instead of addition to set piece flags prevents state corruption, a lesson that transfers to any low-level wasm work. - **Hand-coded wasm is dramatically smaller than generated wasm** (Middle): the checkers module compiles to 853 bytes and uses only 256 bytes of linear memory, showing the cost of tooling and code generation. - **Rust brings safety and expressiveness to wasm without a garbage collector** (Middle): traits, generics, and iterators make complex game logic like move generation far more maintainable than raw wat. - **JavaScript remains the host for WebAssembly 1.0 in the browser** (Late): interop is not optional, and the book treats JS integration as a core skill rather than an afterthought. - **Non-browser hosts unlock IoT and embedded use cases** (Late): the Raspberry Pi lighting project demonstrates that wasm modules can control hardware, not just render UI. - **A multiplayer arena engine shows wasm as a sandboxed plugin system** (Ending): developers upload combat modules, illustrating how wasm enables safe, portable user-generated code. 【Reading Tips】 - **Deep-read the raw wat chapters even if you plan to use Rust exclusively.** The book explicitly argues this foundation pays off when you later build non-browser hosts and need to parse or load modules. - **Skim the checkers game rules if you already know them**, but study the data-structure constraints and bit-flag sections closely; they are the real lesson. - **Treat the Rust checkers rebuild as a comparison exercise**: note what becomes easier (move generation, iterators) and what stays hard (memory layout, host interface). - **Do not skip the interop and hosting chapters** if you care about IoT or plugin architectures; they are where the book moves from browser toy to practical platform. - **Keep the wabt toolchain handy** (wat2wasm, wasm-objdump) and actually run the round-trip examples; the book assumes you will experiment, not just read. 【Coverage Limits】 The excerpts cover the book's conceptual arc, raw wat foundations, Rust checkers rebuild, and the non-browser/IoT direction, but do not include detailed chapter titles or the full JavaScript interop and multiplayer engine implementation. Specific API surfaces and later tooling chapters are only partially represented.