C/C++ & Emscripten

git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
./emsdk install latest     # LLVM, Binaryen, Node, emscripten
./emsdk activate latest
source ./emsdk_env.sh      # per shell (.ps1 on Windows)
emcc --version             # 6.0.x as of September 2026

emcc hello.c -o hello.html     # page + JS + wasm (demo)
emcc hello.c -o hello.js       # JS glue + hello.wasm
emcc hello.c -o hello.mjs      # ES module glue
emcc lib.c -o lib.wasm --no-entry   # standalone Wasm
em++ -std=c++20 -O2 app.cpp -o app.js
emcc -O2 -c a.c -o a.o && emcc a.o b.o -o app.js

#include <emscripten/emscripten.h>
#include <stdlib.h>
#include <string.h>
 
EMSCRIPTEN_KEEPALIVE
int add(int a, int b) { return a + b; }
 
EMSCRIPTEN_KEEPALIVE
double sum(const float *xs, int n) {
  double s = 0;
  for (int i = 0; i < n; i++) s += xs[i];
  return s;
}
 
EMSCRIPTEN_KEEPALIVE
char *greet(const char *name) {  // caller frees
  char *out = malloc(strlen(name) + 8);
  strcpy(out, "Hello, ");
  strcat(out, name);
  return out;
}

#include <emscripten/emscripten.h>
// C++: disable name mangling for exported symbols
extern "C" {
EMSCRIPTEN_KEEPALIVE int add(int a, int b);
}

emcc mathlib.c -O2 -o mathlib.mjs \
  -sMODULARIZE -sEXPORT_ES6 -sEXPORT_NAME=createMath \
  -sENVIRONMENT=web,worker \
  -sEXPORTED_FUNCTIONS=_malloc,_free \
  -sEXPORTED_RUNTIME_METHODS=ccall,cwrap,UTF8ToString,HEAPF32

import createMath from "./mathlib.mjs";
 
const M = await createMath({
  print: (s: string) => console.log(s),     // stdout
  printErr: (s: string) => console.error(s),
  locateFile: (p: string) => `/wasm/${p}`,  // .wasm URL
});
 
// direct: numbers only
M._add(2, 3);
 
// ccall / cwrap convert strings and arrays for you
const greet = M.cwrap("greet", "number", ["string"]);
const p = greet("Ada");
console.log(M.UTF8ToString(p));
M._free(p);
 
M.ccall("add", "number", ["number", "number"], [1, 2]);

// JS allocates, fills, calls, frees
const xs = new Float32Array([1, 2, 3, 4]);
const ptr = M._malloc(xs.byteLength);
M.HEAPF32.set(xs, ptr >> 2);   // index = byte offset / 4
const total = M._sum(ptr, xs.length);
M._free(ptr);

#include <emscripten/bind.h>
#include <string>
#include <vector>
using namespace emscripten;
 
struct Point { float x, y; };
 
class Path {
 public:
  explicit Path(std::string name) : name_(name) {}
  void add(Point p) { pts_.push_back(p); }
  size_t size() const { return pts_.size(); }
  std::string name() const { return name_; }
  void setName(std::string n) { name_ = n; }
  static Path unit() { return Path("unit"); }
 private:
  std::string name_;
  std::vector<Point> pts_;
};
 
float lerp(float a, float b, float t) {
  return a + (b - a) * t;
}
 
EMSCRIPTEN_BINDINGS(shapes) {
  function("lerp", &lerp);
  value_object<Point>("Point")
      .field("x", &Point::x)
      .field("y", &Point::y);
  class_<Path>("Path")
      .constructor<std::string>()
      .function("add", &Path::add)
      .function("size", &Path::size)
      .property("name", &Path::name, &Path::setName)
      .class_function("unit", &Path::unit);
  register_vector<float>("FloatVector");
}

em++ -O2 -lembind shapes.cpp -o shapes.mjs \
  -sMODULARIZE -sEXPORT_ES6 \
  --emit-tsd shapes.d.ts

import createShapes from "./shapes.mjs";
 
const S = await createShapes();
S.lerp(0, 10, 0.25);             // 2.5
const path = new S.Path("route");
path.add({ x: 1, y: 2 });        // value_object: plain JS
path.name = "renamed";           // property()
console.log(path.size());
path.delete();                   // C++ destructor

#include <emscripten/emscripten.h>
 
// A JS function compiled into the output
EM_JS(void, show_title, (const char *s), {
  document.title = UTF8ToString(s);
});
 
EM_JS(int, screen_width, (void), {
  return window.innerWidth;
});
 
void demo(void) {
  show_title("Loaded");
  // inline JS; $0, $1 are the arguments
  EM_ASM({ console.log("x =", $0, "y =", $1); }, 3, 4.5);
  int w = EM_ASM_INT({ return window.innerWidth; });
  double d = EM_ASM_DOUBLE({ return performance.now(); });
  emscripten_run_script("console.log('eval-based')");
  (void)w; (void)d;
}

// -sEXPORTED_RUNTIME_METHODS=FS,IDBFS -lidbfs.js
M.FS.mkdir("/persist");
M.FS.mount(M.IDBFS, { autoPersist: true }, "/persist");
await new Promise<void>((ok, err) =>
  M.FS.syncfs(true, (e) => (e ? err(e) : ok())), // load
);
M.FS.writeFile("/persist/save.json", JSON.stringify(s));
const text = M.FS.readFile("/persist/save.json", {
  encoding: "utf8",
});

#include <emscripten/emscripten.h>
 
static int frame = 0;
 
static void tick(void) {
  frame++;
  // update and render one frame; never block here
  if (frame == 600) emscripten_cancel_main_loop();
}
 
int main(void) {
  // fps 0: use requestAnimationFrame
  // 1: simulate an infinite loop (main does not return)
  emscripten_set_main_loop(tick, 0, 1);
  return 0;
}

em++ game.cpp -O2 -o game.html \
  -sUSE_SDL=2 -sUSE_SDL_IMAGE=2 -sSDL2_IMAGE_FORMATS=png \
  -sMAX_WEBGL_VERSION=2 -sMIN_WEBGL_VERSION=2 \
  -sALLOW_MEMORY_GROWTH \
  --preload-file assets@/assets

emcc -pthread -O2 app.c -o app.js \
  -sPTHREAD_POOL_SIZE=navigator.hardwareConcurrency \
  -sPROXY_TO_PTHREAD \
  -sALLOW_MEMORY_GROWTH

Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp

emcmake cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
emmake make -C legacy/            # plain Makefiles
emconfigure ./configure && emmake make

add_executable(app main.cpp)
if(EMSCRIPTEN)
  set_target_properties(app PROPERTIES SUFFIX ".mjs")
  target_link_options(app PRIVATE
    -sMODULARIZE -sEXPORT_ES6
    -sALLOW_MEMORY_GROWTH
    -lembind --emit-tsd app.d.ts)
endif()

# freestanding: no libc, exports marked in source
clang --target=wasm32 -O3 -nostdlib \
  -Wl,--no-entry -o add.wasm add.c
 
# wasi-sdk: clang + wasi-libc sysroot
$WASI_SDK_PATH/bin/clang --target=wasm32-wasip1 \
  -O2 main.c -o main.wasm
wasmtime run main.wasm

__attribute__((export_name("add")))
int add(int a, int b) { return a + b; }
 
__attribute__((import_module("env"),
               import_name("log")))
void js_log(int x);

emcc lib.c -O3 -o dist/lib.mjs \
  -sMODULARIZE -sEXPORT_ES6 -sEXPORT_NAME=createLib \
  -sENVIRONMENT=web,worker,node \
  -sALLOW_MEMORY_GROWTH -sFILESYSTEM=0 \
  -sEXPORTED_FUNCTIONS=_malloc,_free \
  -sEXPORTED_RUNTIME_METHODS=cwrap,HEAPU8

import createLib from "./dist/lib.mjs";
 
export async function openLib() {
  const M = await createLib();
  type Crc = (p: number, n: number) => number;
  const crc = M.cwrap("crc32", "number",
    ["number", "number"]) as Crc;
  return {
    crc32(bytes: Uint8Array): number {
      const p = M._malloc(bytes.length);
      M.HEAPU8.set(bytes, p);
      try { return crc(p, bytes.length) >>> 0; }
      finally { M._free(p); }
    },
  };
}

emcc tool.c -O2 -o tool.mjs \
  -sENVIRONMENT=node -sNODERAWFS -sEXIT_RUNTIME \
  -sEXPORT_ES6 -sMODULARIZE -sINVOKE_RUN=0 \
  -sEXPORTED_RUNTIME_METHODS=callMain

import createTool from "./tool.mjs";
 
const M = await createTool();
// argv[0] is supplied by the runtime; returns main's code
const code = M.callMain(["--input", "data.csv"]);
console.log("exit code", code);

#include <emscripten/emscripten.h>
 
EM_ASYNC_JS(int, fetch_len, (const char *url), {
  const r = await fetch(UTF8ToString(url));
  return (await r.arrayBuffer()).byteLength;
});
 
EMSCRIPTEN_KEEPALIVE
int load(void) {
  return fetch_len("/data.bin"); // suspends here
}

emcc async.c -O2 -o async.mjs -sJSPI \
  -sMODULARIZE -sEXPORT_ES6 \
  -sEXPORTED_RUNTIME_METHODS=ccall
# fallback for engines without JSPI: -sASYNCIFY

const n = await M.ccall("load", "number", [], [], {
  async: true,
});

#include <emscripten/emscripten.h>
#include <stdio.h>
 
EMSCRIPTEN_KEEPALIVE
void save_game(const char *json) {
  FILE *f = fopen("/persist/save.json", "w");
  fputs(json, f);
  fclose(f);
  EM_ASM(FS.syncfs(false, (e) => e && console.error(e)));
}
 
int main(void) {
  EM_ASM(
    FS.mkdir("/persist");
    FS.mount(IDBFS, {}, "/persist");
    FS.syncfs(true, (e) => e && console.error(e));
  );
  return 0;
}

emcc save.c -lidbfs.js -o save.js -sEXIT_RUNTIME=0

emcc -pthread -O2 -sPTHREAD_POOL_SIZE=4 \
  -sPROXY_TO_PTHREAD work.c -o work.html
emrun --no-browser --port 8080 work.html
# or any server that sends COOP: same-origin and
# COEP: require-corp on the HTML, JS and Wasm