Tagged articles
Wasm
66 articles · Page 1 of 1
The Higress community's November 2026 report details Higress v2.2.5-2.2.6 hardening access boundaries, AI/MCP request stability, and Helm migration controls, while HiRoute 0.6.0 introduces task-difficulty model routing cutting API costs 92%, a five-tier new-model trial framework, subscription-API fallback, and Omarchy Linux desktop support.
AI gatewayCost OptimizationHiRoute
0 likes · 14 min read

The article details debugging a Baidu Map GL white screen caused by CSP blocking worker fetch of data: URIs for image atlases and eval usage in SDK scripts; fixing required adding data: to connect-src and unsafe-eval to script-src in the nginx CSP header.
Baidu Map GLCSPContent Security Policy
0 likes · 16 min read

ghostty-web compiles Ghostty's Zig-based terminal parser into a 404KB WebAssembly module, offering an xterm.js-compatible API with superior compatibility for complex scripts and escape sequences by minimizing WASM boundary crossings through a RenderState snapshot approach.
Frontend DevelopmentGhosttyTerminal Emulation
0 likes · 16 min read

The article benchmarks Alibaba Cloud AI Gateway Serverless Enterprise Edition against self-hosted Higress, showing up to 97.1% lower gateway processing latency for 1MB requests and 90.2% for 10MB requests at 10-100 concurrency, attributing gains to native Envoy plugin optimizations reducing memory copies and Wasm linear memory limitations, while also comparing operational costs and maintenance trade-offs.
AI gatewayEnvoyHigress
0 likes · 10 min read

The article examines how backend performance tuning is evolving from manual, experience‑driven cycles to data‑driven observability, closed‑loop AIOps, serverless/Wasm architectures, and energy‑aware optimization, outlining concrete examples, tools, and forecasts shaping the field through 2026.
AIOpsBackend PerformanceObservability
0 likes · 8 min read


TonyBaiJul 16, 2026 · Backend Development
The article dissects the Go 1.28 planning notes, detailing upcoming compiler memory‑free mechanisms, pre‑compiled Cgo support, revived generic containers, SIMD extensions, Wasm stack‑switching, structured struct tags, sharded counters, and GC scalability work, while explaining the motivations, trade‑offs, and open questions behind each proposal.
CompilerGoGo 1.28
0 likes · 25 min read

The article examines how MoonBit, a newly released Chinese programming language that integrates a compiler, build system, package manager, testing framework and AI assistant, aims to create an AI‑friendly, formally verified toolchain, and evaluates its performance against other low‑resource languages such as Gleam using recent IEEE‑published benchmarks.
AI-friendly programming languageLLM code generationMoonBit
0 likes · 14 min read


Geek LabsJul 4, 2026 · Artificial Intelligence
Astrid is a Rust‑written operating system for AI agents that replaces traditional Python‑based frameworks by introducing immutable “capsules”—isolated WASM or native processes described in Capsule.toml—allowing interchangeable providers, autonomous agents, secure multi‑model routing, and a five‑layer defense model without needing to fork the code.
AI agentsMicrokernelRust
0 likes · 10 min read


TonyBaiJun 25, 2026 · Information Security
In Go 1.27 the standard uuid.NewV7() function produces UUIDs with a constant “7000” segment when compiled to WebAssembly, because browsers deliberately reduce high‑precision timers for Spectre‑style mitigations, causing the 12‑bit random field to collapse to zero and dramatically lowering entropy and collision resistance.
GoUUIDv7Wasm
0 likes · 10 min read

This article explains how the dual‑process architecture of Electron creates a monitoring blind spot, outlines four key challenges—separate runtimes, native crash dumps, unreliable data reporting, and unobservable IPC—and presents a single‑init SDK that provides zero‑config injection, local crash parsing, tRPC monitoring, distributed tracing, memory leak detection, and comprehensive exception protection while keeping overhead negligible.
ElectronObservabilityRUM
0 likes · 16 min read

Ruflo, a Rust‑based, WASM‑powered orchestration platform for Claude Code, enables over 100 AI agents to self‑organize, learn, and securely collaborate across machines via federated communication, offering 32 plug‑and‑play modules and a frictionless CLI installation for developers and enterprises alike.
AI agentsClaudeRuflo
0 likes · 7 min read

CodeFlow is a browser‑only tool that, with just one HTML file, visualizes a project's dependency graph, calculates the explosion radius of code changes, identifies code owners, runs security scans, and exports detailed reports, all without installing software or uploading source code.
D3.jsGitHubTree-Sitter
0 likes · 11 min read

Transformers.js v4 rewrites its WebGPU runtime in C++ and compiles to WASM, delivering ten‑fold faster build times, 10% smaller bundles, and up to four‑fold speedups for BERT‑style models, while supporting over 20 new architectures such as Qwen3.5 and enabling offline, privacy‑preserving AI inference directly in the browser.
Qwen3.5Transformers.jsWasm
0 likes · 8 min read

WebAssembly isn’t just a speed boost for browsers; it fills the gaps where JavaScript struggles by handling heavy computation, binary processing, cross‑language reuse, strong isolation, and multi‑platform core logic, making it a practical engineering tool for today’s complex web applications.
WasmWebAssemblybrowser
0 likes · 13 min read

A new watchboard reveals over 258,000 publicly exposed OpenClaw instances, prompting urgent security measures, while the recently released IronClaw—built with Rust, WASM sandboxing, and multi‑layer defenses—offers a hardened alternative, detailing its orchestrator, worker, and routine engines and how they protect AI assistants from prompt‑injection attacks.
AI securityIronClawOpenClaw
0 likes · 4 min read

Illia Polosukhin, one of the authors of the Transformer paper, rewrote OpenClaw in Rust as IronClaw, adding multiple security layers, a database‑backed memory system, WASM sandboxing, encrypted credential storage, and extensible agent components to make AI agents both safe and efficient.
IronClawRustWasm
0 likes · 7 min read

This article explores common pitfalls and nuanced behaviors in Nginx configuration, illustrating how trailing slashes affect proxy_pass routing, detailing location matching priorities, comparing reload commands, guiding offline installation across architectures, and providing comprehensive settings for deploying Unity WebGL WASM applications with proper MIME types and security headers.
NGINXWasmdeployment
0 likes · 20 min read

When Kubernetes announced the deprecation of Ingress NGINX in March 2026, the author used OpenClaw AI to automatically analyze the existing 60‑plus Ingress resources, set up a Kind test cluster, generate compatible Higress configurations, create WASM plugins for custom snippets, and produce a verified migration handbook—all in less than two minutes of hands‑on work.
HigressWasm
0 likes · 16 min read

This guide details a private MCP gateway architecture using open‑source Higress as the MCP proxy and Nacos as the registry, enabling dynamic tool registration, real‑time Prompt updates, multi‑tenant isolation, and deployment on an air‑gapped Kubernetes cluster without Helm.
DockerHigressKubernetes
0 likes · 20 min read

The article analyzes the challenges of deploying MCP Servers, compares local and remote approaches, and details Higress's open‑source remote MCP Server hosting architecture—including Wasm extensions, multi‑protocol support, Kubernetes deployment, and the forthcoming MCP Marketplace that aims to simplify AI‑agent integration.
API gatewayMCPObservability
0 likes · 14 min read

The article introduces PHP’s newly added online code execution feature in its official documentation, explains how the Run Code button works, and then provides a detailed overview of WebAssembly—including its definition, architecture, key characteristics, and execution workflow—highlighting its relevance for modern web development.
PHPWasmWebAssembly
0 likes · 5 min read

This article explains how China Mobile built a hybrid‑cloud production environment for its customer‑service LLM, using eBPF and WebAssembly plugins from DeepFlow to achieve zero‑intrusion observability, automatically capture full‑stack topology, application/network metrics, and key LLM business indicators such as TTFT, TPOT, and token throughput.
DeepFlowGrafanaLLM
0 likes · 19 min read

WebAssembly (Wasm) is a portable binary format that runs near native speed in browsers, providing sandboxed security and modular deployment, though its ecosystem is still maturing; it shines in compute‑intensive tasks like scientific computing, gaming, and porting native code, and can be integrated with Rust via wasm‑bindgen and wasm‑pack to create npm‑compatible modules that outperform JavaScript on larger workloads, while requiring higher development effort.
JavaScriptRustWasm
0 likes · 15 min read


ArchitectSep 6, 2024 · Artificial Intelligence
This article explains Prompt Engineering, introduces the AI Gateway concept, and demonstrates how to integrate a Geo‑IP plugin with an AI prompt‑modifying plugin in Higress using Go and Wasm, providing configuration examples, implementation details, and sample request‑response scenarios.
AIGeo-IPHigress
0 likes · 11 min read

Bun v1.1.25 boasts a benchmark of 1.29 million HTTP requests per second and adds node:cluster support, V8 C++ API bindings, a five‑fold S3 upload boost, standalone worker executables, Windows OMGJIT for WebAssembly, plus numerous Node.js compatibility fixes, all illustrated with code examples.
BunS3V8
0 likes · 9 min read

The author recounts how a university student discovered open‑source, joined the 2024 Tianchi Cloud Native Programming Challenge, used the AI assistant Tongyi Lingma to master GitHub Actions, built and published a Wasm plugin for Alibaba's Higress gateway, and successfully merged a PR after extensive testing and community feedback.
AI code assistantCI/CDGitHub Actions
0 likes · 7 min read

By compressing GLB files into ZIP, extending Three.js loaders to unzip via a Rust‑compiled WASM tool, encrypting small buffers, and caching morph‑target shaders while spreading mesh rendering across frames, the team shrank model size from 50 MB to 11 MB and cut first‑frame render time from 7 seconds to 0.6 seconds, reducing overall page load from 15 seconds to 5 seconds.
3D model optimizationCompressionThree.js
0 likes · 11 min read

This article demonstrates how to protect large language model (LLM) requests in a cloud‑native environment by using Alibaba Cloud ASM service mesh and a custom Wasm plugin to dynamically inject API keys, enforce custom denial patterns, and optionally route requests through a private LLM for intelligent data‑leak detection.
KubernetesLLMWasm
0 likes · 13 min read

This article explains how the Simple rendering engine built with Wasm and WebGL improves performance and resource efficiency for front‑end interactive technologies such as Lottie, animation sprites, and frame‑difference sequences, and details its architecture, benchmarks, compatibility, and future directions.
LottieWasmrendering engine
0 likes · 16 min read

The article details Higress's migration of its Wasm plugin runtime from V8 to the WebAssembly Micro Runtime (WAMR), showing up to 50% average performance gains and up to double speed for complex plugins, while outlining technical reasons, benchmark results, and migration steps.
AOTBackendHigress
0 likes · 10 min read

This article explains how to extend the Higress cloud‑native gateway with WebAssembly plugins written in Go, C++ or Rust that call Redis for global rate limiting, token‑based AI usage control, and cookie‑based caching, including full code samples, configuration steps, and test results.
Wasmplugin developmentrate limiting
0 likes · 9 min read

WebAssembly, originating from Mozilla’s asm.js experiment and standardized in 2017, offers a compact binary format that outperforms JavaScript and asm.js, enabling near‑native speed for compute‑intensive web and server workloads, with real‑world adoption in graphics, video, AI, and cloud micro‑services.
BackendWASIWasm
0 likes · 36 min read

This article describes how to use Istio Service Mesh, Kubernetes CRDs, and custom WASM Envoy filters to create isolated swim‑lane call chains that prevent branch conflicts, enable full‑link header propagation, and support features such as Java remote debugging, middleware deployment, and hot code reload.
CRDIstioSwimlane
0 likes · 26 min read

This article explains APISIX’s multi‑process architecture and request lifecycle, then explores various ways to develop external plugins—including SideCar‑based plugins, WASM modules, and LuaJIT FFI—detailing their implementation steps, advantages, and limitations to help developers choose the optimal approach for extending the cloud‑native gateway.
APISIXFFILua
0 likes · 14 min read

This article examines the urgent need for standardized, trustworthy computing power measurement, outlines narrow and broad measurement frameworks, and details a technical solution that integrates WASM virtual machines and blockchain with Kubernetes to achieve precise, tamper‑proof resource accounting for modern cloud‑native environments.
KubernetesWasmcloud-native
0 likes · 14 min read

The 2023 frontend review highlights TypeScript’s size and speed gains, ECMAScript 2023 features, evolving frameworks like React, Vue, Svelte, Angular and emerging Qwik, while Rust tooling, Bun, browser changes, AI‑driven low‑code, and WASM progress set the stage for 2024’s LLM‑powered, Rust‑centric, cross‑platform development.
BunD2CHarmonyOS
0 likes · 49 min read

This article details how a data‑compliance company evaluated several cloud‑native API gateways, selected Higress for its Kubernetes‑native architecture, built custom Wasm plugins, leveraged HTTP‑to‑Dubbo conversion, migrated from Nginx Ingress, and achieved higher performance and operational simplicity.
API gatewayHigressKubernetes
0 likes · 13 min read

This article investigates whether WebAssembly truly outperforms JavaScript by compiling Rust to wasm and comparing execution times of Fibonacci and convex‑hull algorithms, revealing that data copying and serialization overhead can make wasm slower in realistic front‑end scenarios.
JavaScriptRustWasm
0 likes · 9 min read

This guide explains how the cloud‑native Higress gateway can lower the expense of using AI large models by centralising API keys, applying rate‑limiting, request filtering, and usage monitoring, and demonstrates a complete OpenAI integration using a WASM plugin with code samples and configuration details.
AIAPI gatewayHigress
0 likes · 13 min read

This article traces the evolution of service mesh from its early concepts through microservice 1.0 and 2.0, analyzes the shortcomings of Envoy‑based sidecars, and explores future directions such as Go‑based data planes, WASM plugins, eBPF/VPP acceleration, QUIC transport, and on‑demand xDS delivery.
EnvoyQUICWasm
0 likes · 17 min read

This article explains WebAssembly's execution model, covering import/export fundamentals, language bindings with wit‑bindgen, the waPC protocol, web browser integration, command‑line runtimes like Wasmtime and WasmEdge, embedded use cases such as Wasm3 on Arduino, and how to embed WASM modules in Envoy plugins and languages like Go, Java, and Python.
Proxy-WASMWasmWasmEdge
0 likes · 22 min read


ByteFEApr 17, 2023 · Fundamentals
This article provides a comprehensive overview of WebAssembly, explaining its import/export model, tooling such as wit‑bindgen and waPC, practical examples for web browsers, command‑line runtimes, embedded systems, and plugin architectures, and demonstrates how to integrate WASM with languages like C, Rust, Go, Java, and Python.
Cross‑PlatformEmbeddedWasm
0 likes · 25 min read

Deploying H.265 on the web is now viable thanks to Chrome 107’s hardware decoding and mature software decoders, but developers must navigate browser support differences, meet specific GPU and OS prerequisites, choose appropriate detection APIs, and implement a fallback hierarchy—from simple video element sources to MSE, WebCodecs, and finally WASM‑based soft decoding—to ensure broad compatibility and optimal performance.
Browser CompatibilityH.265Hardware Decoding
0 likes · 25 min read

This article surveys the diverse scenarios where WebAssembly is applied—from accelerating web applications and providing sandboxed plugins to powering cloud‑native workloads, edge computing, serverless functions, mobile/IoT devices, and blockchain—while also outlining current challenges and future development directions.
BlockchainEdge ComputingWasm
0 likes · 33 min read


ByteFEMar 27, 2023 · Cloud Native
This article surveys WebAssembly's diverse application scenarios—from accelerating browser apps and enabling sandboxed plugins to powering cloud‑native, edge, and blockchain workloads—while highlighting current adoption statistics, key examples, and future development directions.
BlockchainEdge ComputingWasm
0 likes · 28 min read

This article introduces WebAssembly’s efficient, safe, open standards and LLVM‑based compilation pipeline, then guides Rust developers through installing tools, writing and binding simple functions, optimizing performance and bundle size, and explores tooling, runtimes, real‑world use cases, current limitations, and future extensions such as WASI, SIMD, and threads.
Frontend DevelopmentLLVMRust
0 likes · 30 min read

Rust, a compiled, memory‑safe language that enforces ownership and borrowing at compile time, eliminates garbage‑collection overhead, enabling high‑performance front‑end tools like swc and Rome and efficient WebAssembly modules, though its strict rules present a steep learning curve for newcomers.
Programming LanguageRustWasm
0 likes · 21 min read

Alibaba Front‑End Intelligent Technology combines PipCook, DataCook, and imgcook to enable data‑driven UI generation, on‑device AI inference via WASM‑Rust‑SIMD and WebGPU, and applications such as code IntelliSense and design‑to‑code, while outlining a roadmap toward unified AI‑powered interfaces for commerce.
AIData EngineeringTensorFlow.js
0 likes · 33 min read

The Apache APISIX community announced the 2.13.0 LTS release, enhancing stability, adding observability plugins, a new OpenTelemetry tracing plugin, multi‑language (Wasm, Python, Go) support, and a comprehensive list of bug fixes and improvements.
API gatewayApache APISIXLTS Release
0 likes · 7 min read

The article examines how eBPF and WebAssembly are being explored as high‑performance, kernel‑level alternatives to traditional sidecar proxies in service mesh architectures, discussing their benefits, limitations, and the ongoing debate among major mesh providers.
WasmeBPFservice mesh
0 likes · 9 min read

This tutorial walks through building a simple React project, setting up Rust with Cargo and rustup, compiling Rust to WebAssembly using wasm‑bindgen and wasm‑pack, and finally importing the generated Wasm module into React components to demonstrate seamless Rust‑powered frontend functionality.
Frontend DevelopmentReactRust
0 likes · 13 min read

Apache APISIX 2.11.0 adds an LDAP‑based authentication plugin, expands observability with Datadog and SkyWalking plugins, introduces Azure Functions integration, provides early WASM support, and enhances existing plugins, all illustrated with detailed configuration examples and code snippets.
API gatewayAzure FunctionsLDAP
0 likes · 8 min read

This article walks through the design and implementation of a WebAssembly interpreter, covering Wasm fundamentals, binary module structure, decoding into an in‑memory representation, stack‑based virtual machine execution, call‑stack management, and concrete code examples from the open‑source project.
Binary DecodingLow-Level ProgrammingStackVM
0 likes · 24 min read

This article explains how to use WebAssembly and FFmpeg compiled to wasm for client‑side video clipping, covering the basics of WebAssembly, setting up Emscripten, loading ffmpeg.wasm, building a minimal Node server, and adding a slider UI for selecting clip ranges.
EmscriptenFFmpegVideo Clipping
0 likes · 13 min read

This article explains what WebAssembly is, why it was created, how its binary format and compilation model give it near‑native speed compared with JavaScript, and provides a step‑by‑step example of building and loading a simple Wasm module.
EmscriptenFrontend DevelopmentJavaScript
0 likes · 14 min read

This article explains the fundamentals of video frame color spaces, covering how video frames are composed, the differences between RGB and YUV, FFmpeg pixel format definitions, chroma subsampling schemes, storage layouts, and conversion formulas, with code examples and visual illustrations.
FFmpegRGBWasm
0 likes · 13 min read

This article walks through the complete process of creating a browser‑based H.265 video decoder by compiling a trimmed FFmpeg library to WebAssembly, designing a modular player architecture, and integrating the WASM module with JavaScript workers for real‑time playback of high‑resolution streams.
FFmpegH.265JavaScript
0 likes · 22 min read

This guide explains how to push WebAssembly modules to an OCI‑compatible ACR registry using the ORAS client, enable Wasm support in Alibaba Cloud Service Mesh (ASM), and deploy Envoy filters via the ASMFilterDeployment CRD, covering Envoy filter types, pros and cons of Wasm, required CLI commands, and verification steps.
Alibaba CloudEnvoyKubernetes
0 likes · 18 min read

The article reviews the 2020 CNCF report and outlines upcoming cloud‑native trends such as cloud‑based IDEs, edge Kubernetes, WebAssembly, FinOps, Rust adoption, GitOps growth, service catalogs, cross‑cloud control planes, and the rising mainstream of eBPF.
FinOpsGitOpsWasm
0 likes · 9 min read

This talk walks through DingTalk Spreadsheet's journey from zero to a feature‑rich, Excel‑compatible web app, covering its modular architecture, the RangeMan solution for scalable cell management, sophisticated collaboration algorithms like GOT and COT, and performance‑driven rendering techniques using Canvas, double buffering, and a custom text layout engine.
CanvasCollaborationOT
0 likes · 14 min read

To meet the post‑COVID surge in K‑song live broadcasts, the team replaced high‑latency HLS with low‑latency HTTP‑FLV and built the cross‑platform kg‑player SDK—combining MSE, WASM, and WebGL decoding—to automatically adapt streams, reduce stutter, and support iOS/Android, improving performance and powering hundreds of thousands of daily views.
HLSHTTP-FLVSDK
0 likes · 14 min read

This article explores the rise of AI in front‑end development during the pandemic, compares frameworks like TensorFlow.js, ONNX.js and WebNN, presents a performance‑focused case study of MNN.js, and outlines practical acceleration tools for cross‑platform web and mini‑program AI applications.
MNNWasmfrontend
0 likes · 10 min read


21CTODec 7, 2019 · Fundamentals
WebAssembly, now an official W3C web standard, provides a binary, memory‑safe sandbox for compiling languages like C/C++/Rust to run at near‑native speed in browsers and other environments, dramatically improving web performance and expanding the possibilities of web applications.
WasmWebAssemblybinary
0 likes · 7 min read


WecTeamOct 31, 2019 · Frontend Development
This tutorial explains how to compile the ImageMagick C/C++ library to WebAssembly using Emscripten and Docker, configure its dependencies (zlib, libpng, libjpeg, libwebp), build the wasm module, and invoke ImageMagick commands from JavaScript with a virtual file system in the browser.
C++EmscriptenImageMagick
0 likes · 25 min read

This article explores how WebAssembly, compiled via Emscripten from C/C++ code, can accelerate file‑scanning tasks in a web‑based email attachment uploader, detailing the compilation pipeline, runtime communication, performance benchmarks against pure JavaScript, and practical optimizations for worker‑based processing.
EmscriptenJavaScriptWasm
0 likes · 18 min read

This article explains the evolution from asm.js to WebAssembly, compares their performance, outlines implementation strategies—including AssemblyScript, hand‑written asm.js, and C/C++ compilation with Emscripten—and provides practical code examples and tips for integrating WebAssembly into web applications.
BinaryenEmscriptenJavaScript
0 likes · 15 min read
