Files
skills/public/wasm-browser-integration.html
zeekayandHanzo Dev 9e10c1c10e Each llms index points at the other two
hanzoskills.com/llms.txt now opens with the install line, the API
reference index and the company index, so an agent that lands on any
one of the three can find the rest.

robots.txt claimed 537 documents while llms.txt counts 920. The number
is gone from robots.txt; llms.txt derives it.

public/ is regenerated from scripts/site.py, which it had fallen
behind: the copy-prompt menu and agent bar were in the generator and
not in the committed pages. tests/site.mjs passes against the result.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-11 00:27:59 -07:00

754 lines
30 KiB
HTML

<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>wasm-browser-integration</title>
<meta name="color-scheme" content="dark">
<style>
/* Committed to one visual world: a dark instrument panel. No light variant —
the dot field and the hairline rules only read on black, and a naive
inversion would wash both out. Every colour is painted explicitly so the page
never borrows a host background. */
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
:root{
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
--font-zen-pixel-square:'Zen Pixel Square',monospace;
--mono:var(--font-zen-mono);
--sans:var(--font-zen-sans);
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
--r:999px; --r-soft:14px;
}
*{box-sizing:border-box}
html{-webkit-text-size-adjust:100%}
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
/* The dot field. A halftone made of one repeating radial-gradient, faded out
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
/* No overflow clip here: the dot field is inset to the box already, and a clip
would cut off the copy-prompt menu. */
.hero{position:relative;border-bottom:1px solid var(--line)}
.hero::before{content:"";position:absolute;inset:0;
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
background-size:7px 7px;
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
pointer-events:none}
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
nav{border-bottom:1px solid var(--line)}
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
justify-content:space-between;align-items:center;gap:1rem}
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--ink);text-decoration:none;
display:inline-flex;align-items:center;gap:.6rem}
.brand i{font-style:normal;color:var(--faint)}
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--soft);text-decoration:none}
nav a.up:hover{color:var(--ink)}
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
h1 em{font-style:normal;color:var(--faint)}
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
line-height:1.2;font-weight:400}
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
.btn.solid:hover{background:#d8d8d4}
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
/* Copy-prompt selector. Each row copies the prompt for its own target. */
.copy{position:relative;display:inline-flex}
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
padding:.4rem;display:flex;flex-direction:column;
box-shadow:0 12px 32px rgba(0,0,0,.75)}
.menu[hidden]{display:none}
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
white-space:nowrap}
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
.mi:hover .mark{color:var(--ink)}
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
letter-spacing:.1em;text-transform:uppercase}
/* Works-with bar: one scrolling row, name and mark per agent. */
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
display:flex;align-items:center}
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
-webkit-overflow-scrolling:touch;
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
.bar::-webkit-scrollbar{display:none}
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
text-decoration:none;background:var(--ground)}
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
.agent .mark{width:.95rem;height:.95rem}
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
p{margin:0 0 1rem;max-width:70ch}
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
li{margin:.22rem 0}
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
text-decoration-color:var(--line-hi)}
a:hover{text-decoration-color:var(--ink)}
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
display:block;overflow-x:auto}
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
.curl{display:block;background:var(--panel);border:1px solid var(--line);
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
white-space:pre;line-height:1.9}
.curl b{color:var(--ink);font-weight:400}
.curl i{font-style:normal;color:var(--faint)}
/* index */
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
#q:focus{outline:none;border-color:var(--soft)}
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
text-transform:uppercase;margin:0 0 2rem}
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
padding-bottom:.45rem}
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
border-radius:var(--r-soft);text-decoration:none}
.row:hover{background:#0a0a0a}
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
color:var(--faint);font-size:.85rem}
footer a{color:var(--soft)}
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
margin:0 0 2rem;font-size:.85rem}
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
border-bottom:1px solid var(--line);padding-bottom:.4rem}
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
.fmap a:hover{text-decoration:underline}
.fmap div{color:var(--faint);line-height:1.5}
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
@media (max-width:640px){
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
.btns{gap:.5rem}
.btn{padding:.75rem 1.15rem;font-size:.68rem}
.copy,.copy .btn{width:100%;justify-content:center}
.menu{left:0;right:0;min-width:0}
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
.strip b{border-right:0;padding-right:0}
.bar{width:100%}
}
</style>
<link rel="alternate" type="text/markdown" href="/wasm-browser-integration.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/wasm-browser-integration">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/wasm-browser-integration.md
Index: https://hanzoskills.com/llms.txt
Corpus: https://hanzoskills.com/all.md
Append .md to any path for the markdown twin. -->
<body>
<nav><div class="in">
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
<a class="up" href="/">All skills</a>
</div></nav>
<div class="wrap">
<h1>wasm-browser-integration</h1><p class="lede">Loading WebAssembly modules in browsers with JavaScript interop, DOM access, WebGL, and performance optimization</p><h1>WebAssembly Browser Integration</h1>
<p><strong>Scope</strong>: Loading wasm in browsers, JavaScript interop, DOM manipulation, WebGL rendering, and performance patterns <strong>Lines</strong>: ~320 <strong>Last Updated</strong>: 2025-10-25 <strong>Format Version</strong>: 1.0 (Atomic)</p>
<hr>
<h2>When to Use This Skill</h2>
<p>Activate this skill when:</p>
<ul><li>Loading and instantiating wasm modules in browsers</li><li>Passing data between JavaScript and wasm efficiently</li><li>Accessing DOM elements from wasm code</li><li>Rendering graphics with WebGL from wasm</li><li>Using Web Workers with wasm for parallel processing</li><li>Optimizing memory sharing between JS and wasm</li><li>Implementing progressive enhancement with wasm</li><li>Caching compiled wasm modules for faster loading</li></ul>
<h2>Core Concepts</h2>
<h3>Concept 1: Loading and Instantiation</h3>
<p><strong>Methods</strong>:</p>
<ul><li><code>WebAssembly.instantiate()</code>: Compile + instantiate</li><li><code>WebAssembly.instantiateStreaming()</code>: Stream compile (faster)</li><li><code>WebAssembly.compile()</code>: Compile only</li><li><code>WebAssembly.compileStreaming()</code>: Stream compile only</li></ul>
<pre><code class="lang-javascript">// ❌ Slower: Fetch then instantiate
async function loadWasmSlow(url) {
const response = await fetch(url);
const bytes = await response.arrayBuffer();
const { instance } = await WebAssembly.instantiate(bytes);
return instance;
}
// ✅ Faster: Streaming compilation
async function loadWasmFast(url) {
const { instance } = await WebAssembly.instantiateStreaming(
fetch(url)
);
return instance;
}
// With imports
async function loadWasmWithImports(url) {
const importObject = {
env: {
log: (value) =&gt; console.log(value),
now: () =&gt; Date.now(),
}
};
const { instance } = await WebAssembly.instantiateStreaming(
fetch(url),
importObject
);
return instance;
}</code></pre>
<h3>Concept 2: Memory Sharing</h3>
<p><strong>Key points</strong>:</p>
<ul><li>WebAssembly.Memory is shared ArrayBuffer</li><li>JavaScript can read/write directly</li><li>Use TypedArrays for efficient access</li><li>Watch for memory growth invalidating views</li></ul>
<pre><code class="lang-javascript">// Access wasm linear memory
const memory = instance.exports.memory;
const buffer = memory.buffer;
// Create typed views
const uint8View = new Uint8Array(buffer);
const int32View = new Int32Array(buffer);
const float64View = new Float64Array(buffer);
// Write data to wasm memory
function writeString(str, offset) {
const encoder = new TextEncoder();
const bytes = encoder.encode(str);
uint8View.set(bytes, offset);
return bytes.length;
}
// Read data from wasm memory
function readString(offset, length) {
const bytes = uint8View.slice(offset, offset + length);
const decoder = new TextDecoder();
return decoder.decode(bytes);
}
// Handle memory growth
function safeMemoryAccess(instance) {
let buffer = instance.exports.memory.buffer;
let view = new Uint8Array(buffer);
// After wasm calls memory.grow()
if (buffer !== instance.exports.memory.buffer) {
buffer = instance.exports.memory.buffer;
view = new Uint8Array(buffer); // Recreate view
}
return view;
}</code></pre>
<h3>Concept 3: DOM Access via web-sys</h3>
<p><strong>Using web-sys crate</strong> (Rust):</p>
<pre><code class="lang-rust">use wasm_bindgen::prelude::*;
use web_sys::{Document, Element, HtmlElement, window};
#[wasm_bindgen(start)]
pub fn main() {
let document = window()
.unwrap()
.document()
.unwrap();
let body = document.body().unwrap();
// Create element
let div = document
.create_element(&quot;div&quot;)
.unwrap()
.dyn_into::&lt;HtmlElement&gt;()
.unwrap();
div.set_inner_html(&quot;&lt;h1&gt;Hello from Rust!&lt;/h1&gt;&quot;);
div.style().set_property(&quot;color&quot;, &quot;blue&quot;).unwrap();
body.append_child(&amp;div).unwrap();
}
// Event listeners
#[wasm_bindgen]
pub fn setup_button() {
let document = window().unwrap().document().unwrap();
let button = document
.get_element_by_id(&quot;my-button&quot;)
.unwrap()
.dyn_into::&lt;HtmlElement&gt;()
.unwrap();
let closure = Closure::wrap(Box::new(move |_event: web_sys::MouseEvent| {
web_sys::console::log_1(&amp;&quot;Button clicked!&quot;.into());
}) as Box&lt;dyn FnMut(_)&gt;);
button
.add_event_listener_with_callback(&quot;click&quot;, closure.as_ref().unchecked_ref())
.unwrap();
closure.forget(); // Keep closure alive
}</code></pre>
<h3>Concept 4: WebGL Rendering</h3>
<p><strong>Pattern</strong>: Use wasm for computation, WebGL for rendering</p>
<pre><code class="lang-rust">use wasm_bindgen::prelude::*;
use web_sys::{WebGlRenderingContext, WebGlProgram, WebGlShader};
#[wasm_bindgen]
pub struct Renderer {
context: WebGlRenderingContext,
program: WebGlProgram,
}
#[wasm_bindgen]
impl Renderer {
#[wasm_bindgen(constructor)]
pub fn new(canvas_id: &amp;str) -&gt; Result&lt;Renderer, JsValue&gt; {
let document = web_sys::window().unwrap().document().unwrap();
let canvas = document.get_element_by_id(canvas_id).unwrap();
let canvas: web_sys::HtmlCanvasElement = canvas.dyn_into()?;
let context = canvas
.get_context(&quot;webgl&quot;)?
.unwrap()
.dyn_into::&lt;WebGlRenderingContext&gt;()?;
let vert_shader = compile_shader(
&amp;context,
WebGlRenderingContext::VERTEX_SHADER,
r#&quot;
attribute vec4 position;
void main() {
gl_Position = position;
}
&quot;#,
)?;
let frag_shader = compile_shader(
&amp;context,
WebGlRenderingContext::FRAGMENT_SHADER,
r#&quot;
void main() {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
&quot;#,
)?;
let program = link_program(&amp;context, &amp;vert_shader, &amp;frag_shader)?;
context.use_program(Some(&amp;program));
Ok(Renderer { context, program })
}
pub fn render(&amp;self) {
self.context.clear_color(0.0, 0.0, 0.0, 1.0);
self.context.clear(WebGlRenderingContext::COLOR_BUFFER_BIT);
// Draw calls...
}
}
fn compile_shader(
context: &amp;WebGlRenderingContext,
shader_type: u32,
source: &amp;str,
) -&gt; Result&lt;WebGlShader, String&gt; {
let shader = context
.create_shader(shader_type)
.ok_or_else(|| String::from(&quot;Unable to create shader&quot;))?;
context.shader_source(&amp;shader, source);
context.compile_shader(&amp;shader);
if context
.get_shader_parameter(&amp;shader, WebGlRenderingContext::COMPILE_STATUS)
.as_bool()
.unwrap_or(false)
{
Ok(shader)
} else {
Err(context
.get_shader_info_log(&amp;shader)
.unwrap_or_else(|| String::from(&quot;Unknown error&quot;)))
}
}
fn link_program(
context: &amp;WebGlRenderingContext,
vert_shader: &amp;WebGlShader,
frag_shader: &amp;WebGlShader,
) -&gt; Result&lt;WebGlProgram, String&gt; {
let program = context
.create_program()
.ok_or_else(|| String::from(&quot;Unable to create program&quot;))?;
context.attach_shader(&amp;program, vert_shader);
context.attach_shader(&amp;program, frag_shader);
context.link_program(&amp;program);
if context
.get_program_parameter(&amp;program, WebGlRenderingContext::LINK_STATUS)
.as_bool()
.unwrap_or(false)
{
Ok(program)
} else {
Err(context
.get_program_info_log(&amp;program)
.unwrap_or_else(|| String::from(&quot;Unknown error&quot;)))
}
}</code></pre>
<hr>
<h2>Patterns</h2>
<h3>Pattern 1: Progressive Enhancement</h3>
<p><strong>When to use</strong>: Graceful fallback when wasm unavailable</p>
<pre><code class="lang-javascript">async function initApp() {
if (typeof WebAssembly !== &#x27;object&#x27;) {
console.warn(&#x27;WebAssembly not supported, using JavaScript fallback&#x27;);
return new JavaScriptImplementation();
}
try {
const { instance } = await WebAssembly.instantiateStreaming(
fetch(&#x27;app.wasm&#x27;)
);
return new WasmImplementation(instance);
} catch (error) {
console.error(&#x27;Failed to load wasm:&#x27;, error);
return new JavaScriptImplementation();
}
}
class WasmImplementation {
constructor(instance) {
this.wasm = instance.exports;
}
process(data) {
// Use fast wasm implementation
return this.wasm.process(data);
}
}
class JavaScriptImplementation {
process(data) {
// Pure JS fallback (slower but compatible)
return data.map(x =&gt; x * 2);
}
}</code></pre>
<h3>Pattern 2: Module Caching</h3>
<p><strong>Use case</strong>: Cache compiled wasm for instant reload</p>
<pre><code class="lang-javascript">const WASM_CACHE_NAME = &#x27;wasm-cache-v1&#x27;;
async function loadWasmCached(url) {
// Try to get from cache
const cache = await caches.open(WASM_CACHE_NAME);
const cachedResponse = await cache.match(url);
if (cachedResponse) {
const cachedModule = await WebAssembly.compileStreaming(cachedResponse);
const { instance } = await WebAssembly.instantiate(cachedModule);
return instance;
}
// Not cached, fetch and cache
const response = await fetch(url);
cache.put(url, response.clone());
const { instance } = await WebAssembly.instantiateStreaming(response);
return instance;
}</code></pre>
<h3>Pattern 3: Web Worker Integration</h3>
<p><strong>Use case</strong>: Run wasm in background thread</p>
<pre><code class="lang-javascript">// main.js
const worker = new Worker(&#x27;wasm-worker.js&#x27;);
worker.postMessage({
type: &#x27;init&#x27;,
wasmUrl: &#x27;compute.wasm&#x27;
});
worker.postMessage({
type: &#x27;compute&#x27;,
data: largeDataset
});
worker.onmessage = (event) =&gt; {
if (event.data.type === &#x27;result&#x27;) {
console.log(&#x27;Result:&#x27;, event.data.value);
}
};
// wasm-worker.js
let wasmInstance;
self.onmessage = async (event) =&gt; {
if (event.data.type === &#x27;init&#x27;) {
const { instance } = await WebAssembly.instantiateStreaming(
fetch(event.data.wasmUrl)
);
wasmInstance = instance;
self.postMessage({ type: &#x27;ready&#x27; });
}
if (event.data.type === &#x27;compute&#x27; &amp;&amp; wasmInstance) {
const result = wasmInstance.exports.compute(event.data.data);
self.postMessage({
type: &#x27;result&#x27;,
value: result
});
}
};</code></pre>
<h3>Pattern 4: Efficient Data Transfer</h3>
<p><strong>Use case</strong>: Minimize copying between JS and wasm</p>
<pre><code class="lang-rust">use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub struct ImageProcessor {
buffer: Vec&lt;u8&gt;,
}
#[wasm_bindgen]
impl ImageProcessor {
#[wasm_bindgen(constructor)]
pub fn new(size: usize) -&gt; ImageProcessor {
ImageProcessor {
buffer: vec![0; size],
}
}
// Return pointer to internal buffer (zero-copy)
pub fn get_buffer_ptr(&amp;self) -&gt; *const u8 {
self.buffer.as_ptr()
}
pub fn process(&amp;mut self) {
// Process buffer in-place
for pixel in &amp;mut self.buffer {
*pixel = pixel.saturating_add(10);
}
}
}</code></pre>
<pre><code class="lang-javascript">// JavaScript side
const processor = new ImageProcessor(1000000);
const ptr = processor.get_buffer_ptr();
// Get view of wasm memory
const memory = new Uint8Array(
processor.__wbg_get_buffer_memory().buffer,
ptr,
1000000
);
// Write data directly to wasm memory (zero-copy)
memory.set(imageData);
// Process in wasm
processor.process();
// Read result (zero-copy)
const result = memory.slice();</code></pre>
<h3>Pattern 5: Animation Loop</h3>
<p><strong>Use case</strong>: Smooth 60fps rendering with wasm</p>
<pre><code class="lang-rust">use wasm_bindgen::prelude::*;
#[wasm_bindgen]
pub struct Game {
last_timestamp: f64,
}
#[wasm_bindgen]
impl Game {
#[wasm_bindgen(constructor)]
pub fn new() -&gt; Game {
Game { last_timestamp: 0.0 }
}
pub fn update(&amp;mut self, timestamp: f64) -&gt; bool {
let delta = timestamp - self.last_timestamp;
self.last_timestamp = timestamp;
// Update game state
// Return true to continue, false to stop
true
}
}</code></pre>
<pre><code class="lang-javascript">const game = new Game();
function gameLoop(timestamp) {
const shouldContinue = game.update(timestamp);
if (shouldContinue) {
requestAnimationFrame(gameLoop);
}
}
requestAnimationFrame(gameLoop);</code></pre>
<h3>Pattern 6: Error Boundary</h3>
<p><strong>Use case</strong>: Graceful error handling</p>
<pre><code class="lang-javascript">class WasmErrorBoundary {
constructor(wasmInstance) {
this.wasm = wasmInstance;
this.fallbackActive = false;
}
async execute(method, ...args) {
if (this.fallbackActive) {
return this.fallback(method, ...args);
}
try {
return this.wasm.exports[method](...args);
} catch (error) {
console.error(`Wasm error in ${method}:`, error);
this.fallbackActive = true;
return this.fallback(method, ...args);
}
}
fallback(method, ...args) {
// Pure JavaScript implementation
switch (method) {
case &#x27;add&#x27;:
return args[0] + args[1];
default:
throw new Error(`No fallback for ${method}`);
}
}
}</code></pre>
<hr>
<h2>Quick Reference</h2>
<h3>Loading Methods</h3>
<pre><code>Method | Use Case | Performance
------------------------------|------------------------------|-------------
instantiateStreaming(fetch()) | Production (fastest) | Excellent
instantiate(arrayBuffer) | When streaming unavailable | Good
compile() + instantiate() | Cache compiled module | Excellent</code></pre>
<h3>Memory Access Patterns</h3>
<pre><code class="lang-javascript">// Read primitives
const i32 = new Int32Array(memory.buffer)[offset / 4];
const f64 = new Float64Array(memory.buffer)[offset / 8];
// Read string
const bytes = new Uint8Array(memory.buffer, offset, length);
const str = new TextDecoder().decode(bytes);
// Write string
const encoded = new TextEncoder().encode(str);
new Uint8Array(memory.buffer).set(encoded, offset);</code></pre>
<h3>Key Guidelines</h3>
<pre><code>✅ DO: Use instantiateStreaming for best performance
✅ DO: Cache compiled wasm modules
✅ DO: Use Web Workers for heavy computation
✅ DO: Recreate TypedArray views after memory growth
✅ DO: Minimize data copying between JS and wasm
❌ DON&#x27;T: Use fetch().arrayBuffer() unnecessarily
❌ DON&#x27;T: Copy large data when pointers work
❌ DON&#x27;T: Block main thread with heavy wasm work</code></pre>
<hr>
<h2>Anti-Patterns</h2>
<h3>Critical Violations</h3>
<pre><code class="lang-javascript">// ❌ NEVER: Ignore memory growth
const view = new Uint8Array(instance.exports.memory.buffer);
instance.exports.grow_memory(); // Invalidates view!
view[100] = 42; // May crash or write to wrong location
// ✅ CORRECT: Recreate view after growth
function safeWrite(instance, offset, value) {
const view = new Uint8Array(instance.exports.memory.buffer);
view[offset] = value;
}</code></pre>
<p>❌ <strong>Stale memory views</strong>: Undefined behavior, crashes ✅ <strong>Correct approach</strong>: Recreate views or check buffer identity</p>
<h3>Common Mistakes</h3>
<pre><code class="lang-javascript">// ❌ Don&#x27;t: Excessive copying
function processImageBad(imageData) {
const ptr = instance.exports.allocate(imageData.length);
const memory = new Uint8Array(instance.exports.memory.buffer);
// Copy to wasm
memory.set(imageData, ptr);
instance.exports.process(ptr, imageData.length);
// Copy back
const result = memory.slice(ptr, ptr + imageData.length);
instance.exports.deallocate(ptr);
return result;
}
// ✅ Correct: Process in-place
function processImageGood(imageData) {
const ptr = instance.exports.get_shared_buffer();
const memory = new Uint8Array(
instance.exports.memory.buffer,
ptr,
imageData.length
);
memory.set(imageData); // Single copy
instance.exports.process_shared(imageData.length);
// memory already has result, no copy back needed
}</code></pre>
<p>❌ <strong>Multiple copies</strong>: 2x slower, 2x memory ✅ <strong>Better</strong>: Use shared buffers when possible</p>
<hr>
<h2>Related Skills</h2>
<ul><li><code>wasm-fundamentals.md</code> - Core WebAssembly concepts</li><li><code>wasm-rust-toolchain.md</code> - Compiling Rust to wasm</li><li><code>frontend-performance.md</code> - Web performance optimization</li><li><code>web-workers.md</code> - Background processing patterns</li></ul>
<hr>
<p><strong>Last Updated</strong>: 2025-10-25 <strong>Format Version</strong>: 1.0 (Atomic)</p>
<footer>
<div class="fmap">
<div><b>Build</b>
<a href="https://hanzo.app">hanzo.app</a> app builder
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
<div><b>Run</b>
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
<div><b>Account</b>
<a href="https://hanzo.id">hanzo.id</a> sign in
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
<div><b>Company</b>
<a href="https://hanzo.ai">hanzo.ai</a> canonical
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
</div>
<div class="fend"><a href="/wasm-browser-integration.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>