WASM Instructions

https://github.com/SimHacker/MicropolisCore/blob/main/src/Mi...

  ////////////////////////////////////////////////////////////////////////
  // This file uses emscripten's embind to bind C++ classes,
  // C structures, functions, enums, and contents into JavaScript,
  // so you can even subclass C++ classes in JavaScript,
  // for implementing plugins and user interfaces.
  //
  // Wrapping the entire Micropolis class from the Micropolis (open-source
  // version of SimCity) code into Emscripten for JavaScript access is a
  // large and complex task, mainly due to the size and complexity of the
  // class. The class encompasses almost every aspect of the simulation,
  // including map generation, simulation logic, user interface
  // interactions, and more.
  //
  // Strategy for Wrapping
  // 
  // 1. Core Simulation Logic: Focus on the core simulation aspects, such
  //    as the methods to run the simulation, update game states, and handle
  //    user inputs (like building tools and disaster simulations). This is
  //    crucial for any gameplay functionality.
  // 
  // 2. Memory and Performance Considerations: JavaScript and WebAssembly
  //    run in a browser context, which can have memory limitations and
  //    performance constraints. Carefully manage memory allocation,
  //    especially when dealing with the game's map and various buffers.
  // 
  // 3. Direct Memory Access: Provide JavaScript access to critical game
  //    data structures like the map buffer for efficient reading and
  //    writing. This can be done using Emscripten's heap access functions
  //    (HEAP8, HEAP16, HEAP32, etc.).
  // 
  // 4. User Interface and Rendering: This part might not be necessary to
  //    wrap, as modern web technologies (HTML, CSS, WebGL) can be used for
  //    UI. However, providing some hooks for game state (like score, budget,
  //    etc.) to JavaScript might be helpful.
  // 
  // 5. Callbacks and Interactivity: Ensure that key game events and
  //    callbacks are exposed to JavaScript, allowing for interactive and
  //    responsive gameplay.
  // 
  // 6. Optimizations: Where possible, optimize C++ code for WebAssembly,
  //    focusing on critical paths in the simulation loop.
  // 
  // Decisions and Explanations
  //
  // - Excluded Elements:
  //       
  //     - Low-level rendering or platform-specific code, as this can be
  //       handled more efficiently with web technologies.
  //       
  //     - Parts of the code that handle file I/O directly, as file access
  //       in a web context is typically handled differently (e.g., using
  //       browser APIs or server-side support).
  //       
  //     - Any networking or multiplayer code, as web-based
  //       implementations would differ significantly from desktop-based
  //       network code.
  //
  // - Included Elements:
  //       
  //     - Core game mechanics, such as map generation, zone simulation
  //       (residential, commercial, industrial), disaster simulation, and
  //       basic utilities.
  //       
  //     - Game state management, including budgeting, scoring, and city
  //       evaluation.
  //       
  //     - Direct memory access to critical structures like the map
  //       buffer, allowing efficient manipulation from JavaScript.
  // 
  //     - Essential callbacks and event handling mechanisms to ensure
  //       interactivity.
  //
  // Conclusion
  // 
  // Given the complexity and size of the Micropolis class, wrapping the
  // entire class directly is impractical. However, focusing on key areas
  // essential for gameplay and providing efficient interfaces for
  // critical data structures can create a functional and interactive city
  // simulation in a web context. Further optimizations and adjustments
  // would likely be needed based on testing and specific requirements of
  // the web implementation.

You can run wasm in k8s: https://krustlet.dev/

Docker itself can run wasm: https://wasmlabs.dev/articles/docker-without-containers/

There are a few serverless runtimes based on wasm: https://wasmcloud.com/

A lot of those are powered by wasmtime or WasmEdge.

If you’re wanting to be able to just pull down a random app and run it as wasm, that’s inherently harder with wasm, because you have to recompile, and amazing compiling stuff is always harder than it should be. For example I compiled jq to wasm to other day, so you dont have to worry (as much) about the CVEs that was issued recently. https://github.com/rockwotj/jq-wasi

And yet Knuth seems to regard Unicode not as a basic building block of interoperability, but as useless bells-and-whistles, judging by his satirical "iTeX" presentation.