WebAssembly Runtime 2026 基准测试：wasm2c 编译方案为何能击败专用运行时？

引言：一个反直觉的性能发现

2026年7月，WebAssembly 领域出现了一个令人意外的测试结果：将 WebAssembly 模块转译为 C 代码，然后用原生编译器编译成可执行文件，这个"笨办法"在多项性能指标上竟然击败了专门的 WebAssembly 运行时。

这不是标题党。Frank Denis（libsodium 作者、DNSCrypt 项目创始人）在最新的基准测试中发现：wasm2c 生成的可执行文件，几何平均耗时仅为 Wasmer 7.1.0 的 88.7%，仅为 Wasmtime 46.0.0 的 81.4%。要知道，Wasmer 和 Wasmtime 可是当今最主流的 WebAssembly 运行时，背后有庞大的团队持续优化。

更关键的是，这个测试还揭示了一个被忽视的技术趋势：WebAssembly 的 wide_arithmetic 扩展指令正在改变性能格局。支持这一扩展的运行时，性能从"勉强可用"直接跃升到"接近原生"。

本文将深度拆解这场基准测试的技术细节，从编译器优化、内存模型、指令集扩展到部署选型，一次把 WebAssembly 性能优化的工程内幕讲透。

一、测试设计：为什么要测三年跨度的版本对比？

1.1 不是"谁最快"，而是"有没有在变快"

这次基准测试的核心问题不是"哪个 runtime 最快"，而是一个更实际的问题：WebAssembly 运行时真的在持续变快吗？

这个问题的背景是：WebAssembly 生态系统在 2019-2023 年间经历了爆发式增长，大量 runtime 涌现（Wasmer、Wasmtime、WAMR、WasmEdge、Wazero...），每家都宣称自己的性能最优。但开发者真正关心的是：如果我选了一个 runtime，明年会不会被别的项目甩开？我需要频繁迁移吗？

为了回答这个问题，测试选择了三个时间节点：

• 2024年6月：一年前的稳定版本
• 2025年6月：半年前的稳定版本
• 2026年6月：当前最新稳定版本

测试对象包括 10 个主流运行时：

1.2 测试负载：为什么选 libsodium？

测试程序选用 libsodium 的基准测试套件，这是一个成熟、广泛使用的密码学库，涵盖了以下关键场景：

• 对称加密：AES-GCM、ChaCha20-Poly1305
• 非对称加密：Ed25519 签名、X25519 密钥交换
• 哈希函数：SHA-256、SHA-512、BLAKE2b
• 密码哈希：Argon2i、Argon2id、scrypt
• AEAD 构造：secretbox、box

为什么选密码学库？因为：

1. 计算密集型：CPU-bound 场景能直接反映 runtime 的优化水平
2. 无 I/O 干扰：排除系统调用、网络延迟等外部因素
3. 跨语言通用性：密码学算法在所有语言中实现一致，便于对比

1.3 编译配置：四种 WebAssembly 特性组合

测试构建了四种 WebAssembly 变体，逐级启用新特性：

# 1. 基线版本（纯 WebAssembly 1.0）
zig build -Dtarget=wasm32-wasi -Doptimize=ReleaseFast

# 2. 启用 lime1 特性集
zig build -Dtarget=wasm32-wasi -Doptimize=ReleaseFast -Dcpu=lime1

# 3. 启用 SIMD128 向量化
zig build -Dtarget=wasm32-wasi -Doptimize=ReleaseFast -Dcpu=lime1+simd128

# 4. 启用 wide_arithmetic 宽算术扩展
zig build -Dtarget=wasm32-wasi -Doptimize=ReleaseFast -Dcpu=lime1+simd128+wide_arithmetic

lime1 是 WebAssembly 的特性集标识符，包含基本的扩展指令。SIMD128 提供了 128 位向量运算能力。而 wide_arithmetic 是 2026 年引入的关键扩展，我们会在后文详细分析。

1.4 测试环境：控制变量，消除噪音

为了确保数据可靠性，测试环境严格控制：

CPU: AMD Ryzen AI 9 HX 470 (12核24线程)
频率: 固定 2 GHz（关闭睿频）
操作系统: Linux 7.1.0-rc7
编译器: Zig 0.17.0-dev.948+e949341b7
迭代次数: ITERATIONS=3
内存限制: 64 MiB 线性内存

为什么关闭 CPU 睿频？ 频率波动会引入测量噪音，固定频率确保不同 runtime 在相同条件下竞争。

为什么用 Zig 编译？ Zig 提供了跨平台一致性构建，对 WebAssembly 目标有良好的开箱即用支持。

二、性能数据深度解析

2.1 核心指标：相对原生代码的慢速比

测试结果的度量单位是"相对原生代码的慢速比"（slowdown relative to native）。例如：

• 1.33x 表示比原生代码慢 33%
• 2.41x 表示比原生代码慢 141%（即耗时是原生的 2.41 倍）

这个指标直接回答了开发者最关心的问题：如果我选择 WebAssembly，要付出多少性能代价？

2.2 基线版本对比：不启用任何扩展

首先看纯 WebAssembly 1.0 的性能（不启用任何扩展特性）：

2026年最新版本排名

关键发现

1. Wasmtime 是最稳健的优化者

2024: 2.67x
2025: 2.54x (改善 0.13x)
2026: 2.41x (改善 0.13x)

每年稳定改善约 5%，虽然没有跨越式突破，但这种持续优化能力值得信赖。

2. Bun 实现了三年最大跳跃

2024: 26.23x → 2025: 25.77x → 2026: 8.77x

Bun 从"慢得离谱"直接跳到"可用水平"，2025-2026 年间性能提升了 3倍。虽然仍落后 Node.js，但追赶速度惊人。

3. wasm2c 的"笨办法"仍然有效

转译到 C 再编译的方案，性能稳定在前三名。这验证了一个重要观点：编译器优化的核心价值是找到程序员的意图。WebAssembly runtime 需要动态分析指令流，而 wasm2c 直接让 C 编译器发挥几十年积累的优化能力。

4. Wazero 停滞不前

2024: 4.84x → 2025: 4.70x → 2026: 4.72x

作为纯 Go 实现的 runtime，Wazero 两年几乎没有变化。这可能与 Go 语言在数值计算场景的固有局限有关。

2.3 最佳特性组合：每个 runtime 的上限

基线测试展示了公平对比，但实际部署中开发者会启用最大支持特性。以下是每个 runtime 在其最佳特性组合下的性能：

2026年最佳配置排名

核心洞察

wide_arithmetic 是性能分水岭

Wasmer 和 Wasmtime 从"中等水平"直接跃升到"接近原生"，关键就是支持了 wide_arithmetic 扩展：

Wasmer 7.1.0:
- baseline:         2.08x
- lime1+simd128:    1.88x
+ lime1+simd128+wide_arithmetic: 1.33x  ← 降低 36%

Wasmtime 46.0.0:
- baseline:         2.41x
- lime1+simd128:    2.11x
+ lime1+simd128+wide_arithmetic: 1.46x  ← 降低 39%

这个扩展为何如此强大？ 我们在下一节详细分析。

2.4 wasm2c vs 主流 Runtime：内存占用对比

除了执行速度，内存占用也是关键指标。Frank Denis 测量了进程的峰值常驻内存（RSS）：

为什么 wasm2c 内存占用更低？

1. 无引擎开销：直接编译为可执行文件，不需要加载解释器/JIT 编译器
2. 静态链接优化：链接时优化（LTO）可以移除未使用代码
3. 无运行时元数据：不需要维护类型信息、函数表等结构

但要注意：Wasmer 和 Wasmtime 的额外开销是"固定成本"。如果一个服务长时间运行并执行多次 WebAssembly 调用，这个开销会被摊薄。但对于单次执行的 CLI 工具，wasm2c 的轻量级优势明显。

三、wide_arithmetic 扩展：密码学场景的性能革命

3.1 什么是 wide_arithmetic？

wide_arithmetic 是 WebAssembly 的一项提案扩展，专门为高精度整数运算设计。它引入了一组新指令：

;; 128位整数乘法
i128.mul

;; 128位整数加法（带进位）
i128.add_carry

;; 128位整数减法（带借位）
i128.sub_borrow

;; 高位乘法（只取高128位）
i128.mul_high

为什么需要这些指令？

在密码学算法中，大整数运算是核心操作：

• Ed25519 签名：需要 256 位整数模乘
• RSA 加密：需要 1024-4096 位整数运算
• 椭圆曲线：需要 256-521 位域运算

传统 WebAssembly 只支持 32/64 位整数，实现 128 位运算需要用多条指令组合：

;; 传统方式：64位乘法得到128位结果需要4条指令
local.get $a_lo
local.get $a_hi
local.get $b_lo
local.get $b_hi
i64.mul          ;; 低64位
;; 再用 i64.mul_high 得到高64位
;; 再用 i64.add 处理进位
;; ... 总共可能需要 10+ 条指令

而 wide_arithmetic 直接提供了单指令：

;; 使用 wide_arithmetic：一条指令搞定
local.get $a     ;; 128位整数
local.get $b
i128.mul         ;; 直接得到128位结果

3.2 编译器如何利用这一扩展？

现代编译器（如 LLVM）在编译密码学代码时，会识别大整数运算模式并生成高效的机器码。但对于 WebAssembly 目标，传统上只能生成"拆解版"的多条指令。

wide_arithmetic 扩展改变了这个等式。编译器现在可以：

1. 直接映射到硬件指令：x86-64 的 mulq 指令天然支持 128 位乘法
2. 减少寄存器压力：不需要多个临时寄存器存储中间结果
3. 消除分支预测：进位处理由硬件自动完成

3.3 性能影响量化

从测试数据看，wide_arithmetic 的性能提升是跨越式的：

libsodium 算法组            baseline    +wide_arithmetic    改善幅度
------------------------------------------------------------------------
crypto_scalarmult_ed25519   2.67x       1.38x              -48%
crypto_sign_ed25519         2.41x       1.33x              -45%
crypto_core_ed25519         2.23x       1.27x              -43%
crypto_hash_sha512          1.89x       1.42x              -25%

密码学相关算法改善最明显（40-50%），因为这些算法最依赖大整数运算。相比之下，对称加密（如 AES-GCM）主要依赖查表和位运算，改善幅度较小。

3.4 wasm2c 如何支持 wide_arithmetic？

Frank Denis 在测试中为 wasm2c 实现了 wide_arithmetic 支持，实现方式出人意料地简单：

// 生成的 C 代码使用编译器内建函数
#include <stdint.h>

// 128位乘法
static inline void i128_mul(uint64_t a[2], uint64_t b[2], uint64_t result[2]) {
    __uint128_t a128 = (( __uint128_t)a[1] << 64) | a[0];
    __uint128_t b128 = (( __uint128_t)b[1] << 64) | b[0];
    __uint128_t res = a128 * b128;
    result[0] = (uint64_t)res;
    result[1] = (uint64_t)(res >> 64);
}

// 带进位加法
static inline uint64_t i128_add_carry(uint64_t a[2], uint64_t b[2],
                                       uint64_t result[2], uint64_t carry_in) {
    __uint128_t a128 = (( __uint128_t)a[1] << 64) | a[0];
    __uint128_t b128 = (( __uint128_t)b[1] << 64) | b[0];
    __uint128_t res = a128 + b128 + carry_in;
    result[0] = (uint64_t)res;
    result[1] = (uint64_t)(res >> 64);
    return (uint64_t)(res >> 128);  // 返回新的进位
}

核心洞察：C 编译器（gcc/clang）对 __uint128_t 类型有原生优化，生成的机器码与手写汇编相差无几。这使得 wasm2c 的"转译路径"能够充分利用硬件能力。

四、wasm2c 编译方案的工程实践

4.1 wasm2c 工作原理

wasm2c 是 WABT（WebAssembly Binary Toolkit）工具集的一部分，其工作流程：

┌─────────────┐
│ module.wasm │
└──────┬──────┘
       │ wasm2c
       ▼
┌─────────────┐
│ module.c    │  ← 可读的 C 代码
│ module.h    │
└──────┬──────┘
       │ gcc/clang
       ▼
┌─────────────┐
│ executable  │  ← 原生可执行文件
└─────────────┘

生成的 C 代码结构：

// module.h
void WASM_RT_INIT_MODULE_module(void);
uint32_t module_main(void);

// module.c
#include "module.h"
#include <wasm-rt.h>

// 内存段定义
static uint8_t WasmMemory[65536];
static uint8_t* WasmStack[1024];

// 函数实现
uint32_t module_add(uint32_t a, uint32_t b) {
    return a + b;
}

// 模块初始化
void WASM_RT_INIT_MODULE_module(void) {
    wasm_rt_init();
    // 初始化内存、表、全局变量
}

4.2 Segue 内存模式

Frank Denis 在测试中启用了 wasm2c 的 Segue 内存模式，这是性能优化的关键：

传统模式：WebAssembly 线性内存通过数组模拟

static uint8_t WasmMemory[64 * 1024 * 1024];  // 64 MiB

uint32_t wasm_load(uint32_t addr) {
    return WasmMemory[addr] | (WasmMemory[addr+1] << 8);
}

Segue 模式：直接使用原生指针，跳过边界检查

// 使用 guard page 保护，直接访问内存
#define wasm_load(addr) (*(uint16_t*)(native_memory + addr))

Segue 模式的优势：

1. 消除边界检查：依赖操作系统虚拟内存保护
2. 减少指令数：内存访问从函数调用变为直接指针解引用
3. 缓存友好：内存布局与原生程序一致

4.3 部署场景适配

wasm2c 方案最适合以下场景：

1. 嵌入式设备

# 交叉编译到 ARM Cortex-M
arm-none-eabi-gcc -O3 -mcpu=cortex-m4 module.c -o module.elf

WebAssembly runtime 对嵌入式支持有限，而 C 编译器的嵌入式生态成熟。

2. 性能敏感型 CLI 工具

# 编译为静态链接的可执行文件
gcc -O3 -static module.c -o module

无运行时依赖，启动速度快，内存占用低。

3. 高安全要求场景

# 使用 CompCert 形式化验证编译器
ccomp -O module.c -o module

CompCert 保证编译过程语义等价，适用于安全关键应用。

4.4 wasm2c 的局限性

wasm2c 不是银弹，以下场景不适合：

1. 动态加载代码

# ❌ 无法在运行时加载新模块
./app --load-plugin plugin.wasm  # 需要 runtime 支持

2. 多租户隔离

# ❌ 无运行时隔离机制
# 所有编译后的模块共享同一进程空间

3. 即时策略控制

# ❌ 无 fuel、preemption 等运行时特性
# 无法限制模块执行时间或指令数

4. 跨平台分发

# ❌ 需要为每个平台单独编译
# 不如分发单个 .wasm 文件灵活

五、主流 Runtime 深度对比

5.1 Wasmer 7.1.0：性能冠军的技术内幕

Wasmer 在 2026 年测试中综合表现最佳，其架构设计值得深挖：

编译器后端选择

Wasmer 支持三种编译器后端：

// Cranelift：快速编译，中等优化
let engine = Engine::new(Box::new(Cranelift::new()));

// LLVM：慢速编译，最高优化
let engine = Engine::new(Box::new(LLVM::new()));

// Singlepass：即时编译，最低延迟
let engine = Engine::new(Box::new(Singlepass::new()));

测试使用的是 Cranelift 后端，它在编译速度和运行性能间取得平衡。

WASIX 扩展

Wasmer 实现了 WASIX（WebAssembly System Interface eXtended），填补了 WASI 的 POSIX 缺口：

// WASIX 支持更多系统调用
int socket(int domain, int type, int protocol);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void*), void *arg);

这使得 Wasmer 能运行更复杂的应用，如网络服务、多线程程序。

性能优化关键

1. 寄存器分配器改进：从线性扫描升级到图着色算法
2. SIMD 自动向量化：利用 WebAssembly SIMD128 指令
3. 内存访问优化：批量加载/存储指令合并

5.2 Wasmtime 46.0.0：稳定演进的代表

Wasmtime 由 Bytecode Alliance 维护，是最"正统"的 WebAssembly 运行时。

Cranelift 编译器

Wasmtime 与 Cranelift 紧密集成：

// Cranelift 是 Wasmtime 的默认编译后端
// 专为 WebAssembly 优化设计

use cranelift::prelude::*;

// 生成的机器码质量接近 LLVM
fn compile_wasm_function(func: &wasm_func) -> Result<MachineCode> {
    let mut ctx = FunctionBuilder::new();
    // WebAssembly 验证 → Cranelift IR → 机器码
}

Component Model 支持

Wasmtime 率先实现了 Component Model：

(component
  (import "wasi:cli" (instance $cli ...))
  (import "wasi:http" (instance $http ...))

  (core module $m
    (import "cli" (instance ...))
    (import "http" (instance ...))
  )

  (export "api" (instance ...))
)

这提供了类型安全的跨模块接口，适合构建大型应用。

5.3 WAMR 2.4.4：嵌入式场景的最佳选择

WebAssembly Micro Runtime（WAMR）专为嵌入式和 IoT 场景设计：

AOT 编译模式

# 预编译 WebAssembly 到 AOT 文件
wamrc --target=x86_64 --cpu=x86-64-v4 --opt-level=3 -o module.aot module.wasm

# 运行 AOT 文件
iwasm module.aot

AOT（Ahead-Of-Time）编译的优势：

• 零运行时编译开销：加载即执行
• 内存占用低：不需要 JIT 编译器代码
• 确定性执行时间：无编译延迟

限制

测试中 WAMR 不支持 wide_arithmetic：

wamrc: error: unsupported opcode 0xfc13

这限制了其在密码学场景的性能上限。

5.4 Bun 1.3.14：从"慢得离谱"到"可用"

Bun 的性能进化是 2026 年最戏剧性的故事：

2024-2025 的困境

早期 Bun 的 WebAssembly 实现基于 JavaScriptCore，但缺少关键优化：

// 早期实现：每次调用都重新编译
async function runWasm(module, func, args) {
    const instance = await module.instantiate();
    return instance.exports[func](...args);  // 冷启动开销大
}

2026 年的突破

Bun 1.3 引入了原生 WebAssembly 优化：

// 新实现：AOT 编译 + 缓存
const compiled = Bun.wasm.compile(module);  // 首次编译
compiled.cache("./cache/module.wasm.bun");  // 持久化缓存

const instance = compiled.instantiate();
instance.exports.main();  // 后续调用直接执行机器码

虽然性能仍落后 Node.js，但追赶速度预示着未来可期。

六、性能优化实战指南

6.1 选择 Runtime 的决策树

开始
  │
  ├─ 需要动态加载模块？
  │   ├─ 是 → 需要持久运行的 Runtime
  │   │         ├─ 密集计算 → Wasmer / Wasmtime
  │   │         ├─ 网络应用 → Wasmer (WASIX)
  │   │         └─ 嵌入式 → WAMR
  │   │
  │   └─ 否 → 考虑 wasm2c
  │             ├─ CLI 工具 → wasm2c
  │             ├─ 嵌入式设备 → wasm2c
  │             └─ 静态链接 → wasm2c
  │
  ├─ 需要最高性能？
  │   ├─ 密码学场景 → Wasmer (wide_arithmetic)
  │   ├─ 通用计算 → WAMR (AOT)
  │   └─ 单次执行 → wasm2c
  │
  └─ 需要开发便利性？
      ├─ Node.js 生态 → Node.js
      ├─ Bun 全栈 → Bun
      └─ Go 项目 → Wazero

6.2 启用 wide_arithmetic 的完整流程

Step 1: 检查 Runtime 支持

# Wasmer
wasmer --version  # 需要 >= 7.0.0

# Wasmtime
wasmtime --version  # 需要 >= 46.0.0

Step 2: 编译 WebAssembly 模块

# 使用 Zig 编译（推荐）
zig build -Dtarget=wasm32-wasi \
          -Doptimize=ReleaseFast \
          -Dcpu=lime1+simd128+wide_arithmetic

# 或使用 Clang
clang -target wasm32-wasi \
      -O3 \
      -mattr=+simd128,+wide-arithmetic \
      -o module.wasm module.c

Step 3: 运行模块

# Wasmer
wasmer run --enable-all module.wasm

# Wasmtime
wasmtime --enable-all module.wasm

6.3 wasm2c 编译优化技巧

1. 使用 Clang PGO（Profile-Guided Optimization）

# 第一步：编译插桩版本
clang -O3 -fprofile-instr-generate module.c -o module_pgo

# 第二步：运行收集性能数据
./module_pgo
# 生成 default.profdata

# 第三步：使用 PGO 数据重新编译
clang -O3 -fprofile-instr-use module.c -o module_optimized

实测 PGO 能再提升 5-10% 性能。

2. 启用 LTO（Link-Time Optimization）

# 编译时启用 LTO
clang -O3 -flto module.c -o module

LTO 允许跨函数优化，对于 WebAssembly 转译代码特别有效。

3. 针对目标 CPU 优化

# 为本地 CPU 优化
gcc -O3 -march=native module.c -o module

# 或明确指定 CPU 特性
gcc -O3 -march=znver4 -mtune=znver4 module.c -o module

6.4 内存模式选择

wasm2c 提供三种内存模式：

Guard-Page 模式是默认选择，平衡安全与性能：

// wasm2c 编译选项
wasm2c --segue-memory module.wasm -o module.c

七、性能测试方法论

7.1 如何设计可靠的基准测试

控制变量

# 固定 CPU 频率（Linux）
echo 1 | sudo tee /sys/devices/system/cpu/intel_pstate/no_turbo
cpupower frequency-set -g performance

# 禁用地址空间随机化（ASLR）
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

# 绑定 CPU 核心
taskset -c 0 ./module

测量方法

# 使用 perf 测量 CPU 周期
perf stat -e cycles,instructions,cache-misses ./module

# 测量内存占用
/usr/bin/time -v ./module 2>&1 | grep "Maximum resident set size"

# 高精度计时
time (for i in {1..1000}; do ./module; done)

重复测量

# 运行多次取中位数
for i in {1..15}; do
    time ./module 2>&1 | grep real
done | sort | head -n 8 | tail -n 1  # 取中位数

7.2 避免常见的测试陷阱

陷阱 1：冷启动 vs 热运行

# ❌ 错误：只测量热运行
for i in {1..100}; do ./module; done

# ✅ 正确：测量冷启动
hyperfine --warmup 0 --runs 15 './module'

陷阱 2：忽略 JIT 编译时间

# ❌ 错误：JIT 编译时间计入第一次运行
./module --run-once

# ✅ 正确：预热后测量
./module --warmup
./module --measure

陷阱 3：不合理的迭代次数

# ❌ 错误：太少迭代，噪音大
ITERATIONS=1

# ✅ 正确：足够迭代，统计稳定
ITERATIONS=10

八、未来趋势与生态演进

8.1 WebAssembly 特性路线图

短期（2026-2027）

• wide_arithmetic：密码学、大整数运算
• tail_call：函数式编程、递归优化
• multi_memory：多内存段，减少拷贝

中期（2027-2028）

• gc_types：原生垃圾回收类型
• stack_switching：协程、异步编程
• threads：真正的多线程支持

长期（2028+）

• exception_handling：异常机制
• component_model：模块化生态
• wasm64：64 位地址空间

8.2 Runtime 生态竞争格局

性能导向

• Wasmer：全功能、高性能，企业首选
• Wasmtime：标准实现、稳定可靠
• WAVM：极致性能、实验性

场景导向

• WAMR：嵌入式、IoT
• WasmEdge：云原生、边缘计算
• Wazero：Go 生态、无 CGO

开发体验导向

• Node.js：前端开发、快速原型
• Bun：全栈开发、一体化方案

8.3 wasm2c 的演进方向

Frank Denis 的测试验证了 wasm2c 的价值，未来可能的发展：

1. 自动特性检测：根据 WebAssembly 模块特性自动启用/禁用优化
2. 多语言后端：除了 C，支持转译到 Rust、Zig 等
3. 内存安全增强：集成 Fil-C 等内存安全工具
4. 形式化验证集成：与 CompCert 等验证编译器深度集成

九、结论：性能没有银弹，但存在最优解

核心发现总结

1. WebAssembly 性能正在持续改善

   • Wasmtime 每年稳定提升 5%
   • Bun 实现了 3 倍跳跃式进步
   • 但部分 runtime（如 Wazero）进展缓慢

2. wide_arithmetic 是密码学场景的游戏规则改变者

   • 支持该特性的 runtime 性能提升 35-40%
   • 目前仅 Wasmer、Wasmtime、wasm2c 支持
   • 密码学、大整数运算是最大受益场景

3. wasm2c 仍是高性能场景的有力选择

   • 几何平均耗时比 Wasmer 低 11.3%
   • 内存占用低 30-40%
   • 但牺牲了动态加载、运行时隔离等能力

4. 部署场景决定技术选型

   • CLI 工具、嵌入式：wasm2c
   • 服务端长期运行：Wasmer / Wasmtime
   • 嵌入式 IoT：WAMR
   • 前端开发：Node.js / Bun

给开发者的建议

如果你是 WebAssembly 新手：

• 从 Wasmtime 开始，文档完善、生态成熟
• 关注 wide_arithmetic 特性，为未来做准备

如果你追求极致性能：

• 评估 wasm2c 方案的可行性
• 使用 Clang PGO + LTO 优化编译

如果你开发密码学应用：

• 必须选择支持 wide_arithmetic 的 runtime
• Wasmer 和 Wasmtime 是当前最佳选择

如果你是嵌入式开发者：

• WAMR 是最成熟的方案
• wasm2c 可作为轻量化替代

最后的思考

WebAssembly 的性能故事不是"谁最快"，而是"在特定场景下谁最合适"。wasm2c 用最朴素的方案证明了：有时候，最好的优化不是更聪明的运行时，而是让现有编译器发挥全部实力。

正如 Frank Denis 所说："The best WebAssembly runtime may still be no runtime at all." 这不是否定 WebAssembly 的价值，而是提醒我们：技术的选择应基于场景需求，而非盲目追求新颖。

2026 年的 WebAssembly 生态已经足够成熟，关键在于如何根据你的具体需求，做出最优的技术选型。

附录：完整测试数据

A. 基线版本（无扩展）性能数据

B. 最佳配置性能数据（2026）

C. wide_arithmetic 性能影响对比

D. 内存占用对比

参考资源：

• Frank Denis 博客原文
• WebAssembly 性能基准测试 2026
• wide_arithmetic 提案规范
• WABT wasm2c 工具
• Wasmer 文档
• Wasmtime 文档