Benchmarks for ECMAScript parsers compiled to native binaries (Zig, Rust), measuring raw parsing speed without any JavaScript runtime overhead.

Language: Zig

A high-performance & spec-compliant JavaScript/TypeScript compiler toolchain written in Zig.

Language: Rust

A high-performance JavaScript and TypeScript parser written in Rust.

Language: Rust

An extensible Rust-based platform for compiling and bundling JavaScript and TypeScript.

File size: 7.83 MB

File size: 2.95 MB

File size: 2.24 MB

File size: 0.07 MB

The ECMAScript specification defines a set of early errors that conformant implementations must report before execution. Some of these are detectable during parsing from local context alone, like return outside a function, yield outside a generator, invalid destructuring, etc. Others require knowledge of the program's scope structure and bindings, such as redeclarations, unresolved exports, private fields used outside their class, etc.

Parsers handle this differently: SWC checks some scope-dependent errors during parsing itself, while Yuku and Oxc defer them entirely to a separate semantic analysis pass. This keeps parsing fast and lets each consumer opt in only to the work it actually needs. A formatter, for example, only needs the AST and should not pay the cost of scope resolution.

The benchmarks below measure parsing followed by this additional pass, which builds a scope tree and symbol table, resolves identifier references to their declarations, and reports the remaining early errors. Together, parsing and semantic analysis cover the full set of early errors required by the specification.

• Bun - JavaScript runtime and package manager
• Rust - For building Rust-based parsers
• Zig - For building Zig-based parsers (requires nightly/development version)

1. Clone the repository:

git clone https://github.com/yuku-toolchain/ecmascript-parser-benchmark-native.git
cd ecmascript-parser-benchmark-native

2. Install dependencies:

bun install

3. Download the benchmark files:

bun load-files

4. Build the parsers:

bun run build

5. Run benchmarks:

bun bench

This will run benchmarks on all test files. Results are saved to the result/ directory.

Parsing is timed in-process to isolate it from process startup, dynamic linking, file I/O, and memory teardown, which would otherwise dominate the measurement on smaller files.

The source is read once, then each parser runs 50 warmup iterations followed by 300 timed iterations. A monotonic clock wraps only the parse call (plus the semantic pass for the semantic variants); allocation and teardown happen outside the timed region, and the result passes through an optimization barrier so the work cannot be elided. Reported figures are the median, minimum, and 99th percentile of the timed runs.

Binaries are built with release optimizations: Rust with cargo build --release (LTO, single codegen unit, symbol stripping) and Zig with zig build --release=fast. Each uses a fast general-purpose allocator (Rust mimalloc, Zig smp_allocator).