This repository is a fork of yuku-toolchain/ecmascript-parser-benchmark-native, maintained to update parser benchmark data and add parsers.

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.

Language: Rust

The next-generation SWC JavaScript and TypeScript parser.

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, Oxc, and SWC Next provide 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. SWC Next enables SyntaxChecks::all(); Yuku enables check = true. These timings do not establish equivalent conformance coverage.

• Node.js 22.18 or later - Script runtime
• pnpm - Package manager
• Rust - For building Rust-based parsers
• Zig 0.17.0 - Required by Yuku 0.27.0

1. Clone the repository:

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

2. Install dependencies:

pnpm install

3. Download the benchmark files:

pnpm run load-files

4. Build the parsers:

pnpm run build

5. Run benchmarks:

pnpm 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).