Skip to content

refactor(runtime): share indexed data module loading#781

Merged
frostney merged 3 commits into
mainfrom
codex/indexed-data-runtime-module-loader
Jun 24, 2026
Merged

refactor(runtime): share indexed data module loading#781
frostney merged 3 commits into
mainfrom
codex/indexed-data-runtime-module-loader

Conversation

@frostney

Copy link
Copy Markdown
Owner

Summary

  • Extracted a shared TGocciaIndexedDataModuleRuntimeExtension adapter for indexed-record runtime module imports.
  • Kept CSV, TSV, and JSONL parser construction, parse-error wrapping, runtime builtins, extension registration, and public APIs in their existing format-specific units.
  • Non-goal: no data-format semantics or import/export behavior changes.

Testing

  • Verified no regressions and confirmed the new feature or bugfix in end-to-end JavaScript/TypeScript tests
  • Updated documentation
  • Optional: Verified no regressions and confirmed the new feature or bugfix in native Pascal tests (if AST, scope, evaluator, or value types changed)
  • Optional: Verified no benchmark regressions or confirmed benchmark coverage for the change

Commands run:

./build.pas tests
./build.pas testrunner
./build/GocciaTestRunner tests/language/modules/tabular-import.js tests/language/modules/jsonl-import.js
./format.pas --check
./build/GocciaTestRunner tests
./build/GocciaTestRunner tests --mode=bytecode

Documentation: not updated because this refactor preserves existing runtime module import behavior and public APIs.

Extract the common indexed-record runtime module loading adapter used by CSV, TSV, and JSONL imports while keeping format-specific parsers, builtins, extension checks, and parse-error wrapping in their existing runtime extension units.

Verification:
- ./build.pas tests
- ./build.pas testrunner
- ./build/GocciaTestRunner tests/language/modules/tabular-import.js tests/language/modules/jsonl-import.js
- ./format.pas --check
- ./build/GocciaTestRunner tests
- ./build/GocciaTestRunner tests --mode=bytecode
@vercel

vercel Bot commented Jun 22, 2026

Copy link
Copy Markdown

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment
Project Deployment Actions Updated (UTC)
gocciascript-homepage Ignored Ignored Preview Jun 24, 2026 4:56pm

Request Review

@coderabbitai

coderabbitai Bot commented Jun 22, 2026

Copy link
Copy Markdown
Contributor

Review Change Stack

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: d37f4cfc-e0d6-4ee6-b4be-8e47b865094d

📥 Commits

Reviewing files that changed from the base of the PR and between f052da4 and df5a0b3.

📒 Files selected for processing (1)
  • source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas
🚧 Files skipped from review as they are similar to previous changes (1)
  • source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas

📝 Walkthrough

Walkthrough

A new unit adds TGocciaIndexedDataModuleRuntimeExtension for shared module loading. CSV, JSONL, and TSV runtime extensions now inherit from it and implement format-specific path matching and record parsing.

Changes

Indexed Data Module Extension Extraction

Layer / File(s) Summary
TGocciaIndexedDataModuleRuntimeExtension contract and implementation
source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas
New unit declares the abstract base class with MatchesModulePath and ParseModuleRecords hooks, and implements TryLoadModule with content loading, record parsing, module creation, indexed export table population, and nested try/finally cleanup.
CSV extension refactored to use base class
source/units/Goccia.RuntimeExtensions.CSV.pas
TGocciaCSVRuntimeExtension switches to the new base class, removes TryLoadModule, adds Goccia.FileExtensions, and implements CSV path matching and parsing with TGocciaCSVParser.
JSONL extension refactored to use base class
source/units/Goccia.RuntimeExtensions.JSONL.pas
TGocciaJSONLRuntimeExtension switches to the new base class, removes TryLoadModule, updates unit imports, and implements JSONL path matching and parsing with TGocciaJSONLParser.
TSV extension refactored to use base class
source/units/Goccia.RuntimeExtensions.TSV.pas
TGocciaTSVRuntimeExtension switches to the new base class, removes TryLoadModule, trims unit imports, and implements TSV path matching and parsing with TGocciaTSVParser.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

  • frostney/GocciaScript#162: Introduced the content-provider loading path that the extracted base class now reuses for indexed data modules.
🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title clearly summarizes the main refactor: sharing indexed data module loading across runtime extensions.
Description check ✅ Passed The description matches the template with a summary and testing section, and includes non-goals and validation commands.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.

✏️ Tip: You can configure your own custom pre-merge checks in the settings.


Comment @coderabbitai help to get the list of available commands.

@github-actions

github-actions Bot commented Jun 22, 2026

Copy link
Copy Markdown
Contributor

Suite Timing

Test Runner (interpreted: 10,799 passed; bytecode: 10,799 passed)
Metric Interpreted Bytecode
Total 10799 10799
Passed 10799 ✅ 10799 ✅
Workers 4 4
Test Duration 16.52s 16.72s
Lex (cumulative) 503.5ms 516.9ms
Parse (cumulative) 362.1ms 369.2ms
Compile (cumulative) 730.4ms
Execute (cumulative) 53.5ms 36.39s
Engine Total (cumulative) 919.0ms 38.01s
Lex (avg/worker) 125.9ms 129.2ms
Parse (avg/worker) 90.5ms 92.3ms
Compile (avg/worker) 182.6ms
Execute (avg/worker) 13.4ms 9.10s
Engine Total (avg/worker) 229.8ms 9.50s

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Test runner worker shutdown frees thread-local heaps in bulk; that shutdown reclamation is not counted as GC collections or collected objects.

Metric Interpreted Bytecode
GC Live 271.52 MiB 269.28 MiB
GC Peak Live 299.94 MiB 293.42 MiB
GC Allocated During Run 433.42 MiB 425.14 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 188 188
GC Collected Objects 1,277,898 1,249,583
Heap Start Allocated 179.0 KiB 179.0 KiB
Heap End Allocated 3.65 MiB 3.65 MiB
Heap Delta Allocated 3.47 MiB 3.47 MiB
Heap Delta Free 1.65 MiB 1.65 MiB
Benchmarks (interpreted: 430; bytecode: 430)
Metric Interpreted Bytecode
Total 430 430
Workers 4 4
Duration 2.81min 2.77min

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Benchmark runner performs explicit between-file collections, so collection and collected-object counts can be much higher than the test runner.

Metric Interpreted Bytecode
GC Live 6.08 MiB 6.08 MiB
GC Peak Live 88.67 MiB 72.22 MiB
GC Allocated During Run 14.36 GiB 9.29 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 3,586 3,471
GC Collected Objects 224,232,361 206,926,733
Heap Start Allocated 3.35 MiB 3.35 MiB
Heap End Allocated 3.35 MiB 3.35 MiB
Heap Delta Allocated 128 B 128 B

Measured on ubuntu-latest x64.

@github-actions

github-actions Bot commented Jun 22, 2026

Copy link
Copy Markdown
Contributor

test262 Conformance

🚫 Regression vs cached main baseline. 3 previously-passing test(s) now fail; pass count Δ +32. This run blocks merge — see "Newly failing" below.

Category Run Passed Δ Pass Failed Pass-rate Δ Rate
built-ins 23,643 22,516 +1 1,127 95.2% ±0pp
harness 116 116 ±0 0 100.0% ±0pp
intl402 3,341 3,332 -3 9 99.7% -0.1pp
language 23,711 23,706 +34 5 100.0% +0.1pp
staging 1,482 1,104 ±0 376 74.5% ±0pp
total 52,293 50,774 +32 1,517 97.1% +0.1pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
built-ins/TypedArray 99.9% ±0pp 1,445 / 1,446
intl402/Temporal 99.8% -0.1pp 2,024 / 2,029
built-ins/Object 99.7% ±0pp 3,401 / 3,411
Per-test deltas (+35 / -3)

Newly failing (3):

  • intl402/DateTimeFormat/prototype/formatToParts/compare-to-temporal.js
  • intl402/Temporal/ZonedDateTime/prototype/hoursInDay/dst-less-than-hour.js
  • intl402/Temporal/ZonedDateTime/prototype/hoursInDay/same-date-starts-twice.js

Newly passing (35):

  • built-ins/Number/prototype/toExponential/undefined-fractiondigits.js
  • language/expressions/call/tco-call-args.js
  • language/expressions/call/tco-member-args.js
  • language/expressions/call/tco-non-eval-function-dynamic.js
  • language/expressions/call/tco-non-eval-function.js
  • language/expressions/call/tco-non-eval-global.js
  • language/expressions/call/tco-non-eval-with.js
  • language/expressions/coalesce/tco-pos-null.js
  • language/expressions/coalesce/tco-pos-undefined.js
  • language/expressions/comma/tco-final.js
  • language/expressions/conditional/tco-cond.js
  • language/expressions/conditional/tco-pos.js
  • language/expressions/logical-and/tco-right.js
  • language/expressions/logical-or/tco-right.js
  • language/expressions/tagged-template/tco-call.js
  • language/expressions/tagged-template/tco-member.js
  • language/expressions/tco-pos.js
  • language/statements/block/tco-stmt-list.js
  • language/statements/block/tco-stmt.js
  • language/statements/do-while/tco-body.js
  • language/statements/for/tco-const-body.js
  • language/statements/for/tco-let-body.js
  • language/statements/for/tco-lhs-body.js
  • language/statements/for/tco-var-body.js
  • language/statements/if/tco-else-body.js
  • language/statements/if/tco-if-body.js
  • language/statements/labeled/tco.js
  • language/statements/return/tco.js
  • language/statements/switch/tco-case-body-dflt.js
  • language/statements/switch/tco-case-body.js
  • language/statements/switch/tco-dftl-body.js
  • language/statements/try/tco-catch-finally.js
  • language/statements/try/tco-catch.js
  • language/statements/try/tco-finally.js
  • language/statements/while/tco-body.js

Steady-state failures are non-blocking; regressions vs the cached main baseline (lower total pass count, or any PASS → non-PASS transition) fail the conformance gate. Measured on ubuntu-latest x64, bytecode mode. Areas grouped by the first two test262 path components; minimum 25 attempted tests, areas already at 100% excluded. Δ vs main compares against the most recent cached main baseline.

@frostney frostney marked this pull request as ready for review June 24, 2026 16:23
@coderabbitai coderabbitai Bot added the internal Refactoring, CI, tooling, cleanup label Jun 24, 2026

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧹 Nitpick comments (1)
source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas (1)

49-52: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Protect AModule immediately after creation.

Line 50 performs work after AModule is acquired but before the cleanup finally starts. Move that assignment inside the guarded block so future setter/work failures cannot leak the module.

♻️ Proposed exception-safety cleanup
-    AModule := TGocciaModule.Create(AResolvedPath);
-    AModule.LastModified := Content.LastModified;
     LoadSucceeded := False;
+    AModule := TGocciaModule.Create(AResolvedPath);
     try
+      AModule.LastModified := Content.LastModified;
       for I := 0 to Records.Elements.Count - 1 do
         AModule.ExportsTable.AddOrSetValue(IntToStr(I), Records.Elements[I]);

Based on learnings, this codebase follows the canonical acquire-then-protect pattern: assign the constructor result, immediately open try..finally, and free in finally.

🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas` around lines 49
- 52, The module created in the acquisition path is not protected immediately,
so failures during the post-construction assignment can leak it. In the code
around TGocciaModule.Create and the LoadSucceeded setup, move the
AModule.LastModified assignment into the same guarded try..finally block
immediately after creation so the canonical acquire-then-protect pattern is
preserved and the module is always freed on failure.

Source: Learnings

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas`:
- Around line 49-52: The module created in the acquisition path is not protected
immediately, so failures during the post-construction assignment can leak it. In
the code around TGocciaModule.Create and the LoadSucceeded setup, move the
AModule.LastModified assignment into the same guarded try..finally block
immediately after creation so the canonical acquire-then-protect pattern is
preserved and the module is always freed on failure.

ℹ️ Review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 0c3159dc-1a2e-4014-80b9-5daff3040f69

📥 Commits

Reviewing files that changed from the base of the PR and between 0615cab and f052da4.

📒 Files selected for processing (4)
  • source/units/Goccia.RuntimeExtensions.CSV.pas
  • source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas
  • source/units/Goccia.RuntimeExtensions.JSONL.pas
  • source/units/Goccia.RuntimeExtensions.TSV.pas

frostney added 2 commits June 24, 2026 17:51
Move the LastModified assignment into the guarded module acquisition block so any failure after TGocciaModule.Create frees the partially-created module.

Validation:
- ./format.pas source/units/Goccia.RuntimeExtensions.IndexedDataModule.pas
- ./build.pas testrunner (failed before clean with FPC internal error 200611031)
- ./build.pas --clean testrunner
- ./build/GocciaTestRunner tests/language/modules/tabular-import.js tests/language/modules/jsonl-import.js
- ./build/GocciaTestRunner tests/language/modules/tabular-import.js tests/language/modules/jsonl-import.js --mode=bytecode
- ./format.pas --check
- git diff --check
@github-actions

github-actions Bot commented Jun 24, 2026

Copy link
Copy Markdown
Contributor

Benchmark Results

430 benchmarks

Interpreted: 🟢 99 improved · 🔴 34 regressed · 🆕 18 new · 279 unchanged · avg +2.5%
Bytecode: 🟢 29 improved · 🔴 47 regressed · 🆕 18 new · 336 unchanged · avg -1.0%

arraybuffer.js — Interp: 🟢 4, 10 unch. · avg +5.3% · Bytecode: 🟢 1, 🔴 1, 12 unch. · avg -4.2%
Benchmark Interpreted Δ Bytecode Δ
create ArrayBuffer(0) 125,801 ops/sec [106,466..127,904] → 123,048 ops/sec [102,506..139,631] ~ overlap (-2.2%) 151,932 ops/sec [106,044..179,864] → 117,846 ops/sec [86,358..160,552] ~ overlap (-22.4%)
create ArrayBuffer(64) 115,912 ops/sec [115,450..117,017] → 122,105 ops/sec [113,057..139,474] ~ overlap (+5.3%) 146,739 ops/sec [143,869..203,843] → 145,242 ops/sec [109,633..155,824] ~ overlap (-1.0%)
create ArrayBuffer(1024) 104,611 ops/sec [79,964..106,355] → 113,255 ops/sec [111,722..137,597] 🟢 +8.3% 135,789 ops/sec [134,247..137,484] → 111,678 ops/sec [80,055..132,215] 🔴 -17.8%
create ArrayBuffer(8192) 66,116 ops/sec [62,717..66,691] → 78,553 ops/sec [76,467..81,188] 🟢 +18.8% 74,400 ops/sec [54,866..77,715] → 77,908 ops/sec [51,212..87,719] ~ overlap (+4.7%)
slice full buffer (64 bytes) 91,616 ops/sec [90,165..96,431] → 93,711 ops/sec [92,853..95,665] ~ overlap (+2.3%) 116,693 ops/sec [112,390..117,946] → 114,250 ops/sec [113,674..117,817] ~ overlap (-2.1%)
slice half buffer (512 of 1024 bytes) 85,734 ops/sec [84,889..87,100] → 88,957 ops/sec [88,402..89,533] 🟢 +3.8% 125,822 ops/sec [106,043..127,918] → 111,512 ops/sec [109,585..113,119] ~ overlap (-11.4%)
slice with negative indices 80,329 ops/sec [78,037..87,081] → 84,495 ops/sec [84,261..84,804] ~ overlap (+5.2%) 111,600 ops/sec [108,867..112,416] → 112,746 ops/sec [112,428..129,454] 🟢 +1.0%
slice empty range 89,156 ops/sec [87,223..92,218] → 93,622 ops/sec [91,793..98,105] ~ overlap (+5.0%) 114,135 ops/sec [109,128..115,162] → 113,908 ops/sec [111,507..116,765] ~ overlap (-0.2%)
byteLength access 233,309 ops/sec [230,789..239,739] → 254,723 ops/sec [231,299..287,208] ~ overlap (+9.2%) 320,995 ops/sec [303,600..332,631] → 316,049 ops/sec [292,799..318,321] ~ overlap (-1.5%)
Symbol.toStringTag access 189,058 ops/sec [186,873..191,999] → 193,595 ops/sec [191,796..223,275] ~ overlap (+2.4%) 245,658 ops/sec [236,436..270,195] → 229,364 ops/sec [207,499..240,351] ~ overlap (-6.6%)
ArrayBuffer.isView 154,664 ops/sec [151,900..160,438] → 153,955 ops/sec [147,422..167,252] ~ overlap (-0.5%) 235,946 ops/sec [221,485..272,875] → 221,661 ops/sec [218,796..287,738] ~ overlap (-6.1%)
clone ArrayBuffer(64) 118,698 ops/sec [115,418..144,001] → 123,005 ops/sec [121,270..123,325] ~ overlap (+3.6%) 165,738 ops/sec [159,890..168,459] → 164,244 ops/sec [154,937..186,288] ~ overlap (-0.9%)
clone ArrayBuffer(1024) 104,498 ops/sec [104,057..106,798] → 114,534 ops/sec [112,287..116,310] 🟢 +9.6% 141,122 ops/sec [139,590..184,232] → 145,730 ops/sec [142,849..150,691] ~ overlap (+3.3%)
clone ArrayBuffer inside object 79,523 ops/sec [77,517..82,938] → 82,765 ops/sec [81,643..84,480] ~ overlap (+4.1%) 100,602 ops/sec [99,958..106,770] → 102,421 ops/sec [101,685..116,663] ~ overlap (+1.8%)
arrays.js — Interp: 🟢 4, 15 unch. · avg +3.4% · Bytecode: 🔴 3, 16 unch. · avg -3.3%
Benchmark Interpreted Δ Bytecode Δ
Array.from length 100 1,920 ops/sec [1,249..2,543] → 1,949 ops/sec [1,587..2,030] ~ overlap (+1.5%) 2,864 ops/sec [2,779..2,944] → 2,735 ops/sec [1,663..3,178] ~ overlap (-4.5%)
Array.from 10 elements 63,274 ops/sec [62,046..63,714] → 66,269 ops/sec [58,340..66,328] ~ overlap (+4.7%) 72,242 ops/sec [71,277..87,114] → 69,518 ops/sec [54,203..73,684] ~ overlap (-3.8%)
Array.of 10 elements 85,340 ops/sec [80,333..88,283] → 86,038 ops/sec [83,089..95,459] ~ overlap (+0.8%) 105,553 ops/sec [90,097..116,150] → 78,480 ops/sec [71,194..105,674] ~ overlap (-25.6%)
spread into new array 91,495 ops/sec [88,091..93,753] → 97,347 ops/sec [96,169..128,659] 🟢 +6.4% 54,570 ops/sec [53,831..87,196] → 50,136 ops/sec [35,069..52,749] 🔴 -8.1%
map over 50 elements 3,421 ops/sec [3,324..3,456] → 3,586 ops/sec [3,553..3,606] 🟢 +4.8% 5,458 ops/sec [5,295..5,628] → 5,606 ops/sec [5,570..5,628] ~ overlap (+2.7%)
filter over 50 elements 3,289 ops/sec [3,183..3,376] → 3,445 ops/sec [3,383..3,467] 🟢 +4.7% 5,956 ops/sec [5,020..6,722] → 5,532 ops/sec [5,060..5,979] ~ overlap (-7.1%)
reduce sum 50 elements 3,328 ops/sec [3,235..3,724] → 3,452 ops/sec [3,360..4,212] ~ overlap (+3.7%) 5,438 ops/sec [5,082..5,774] → 5,283 ops/sec [5,261..5,327] ~ overlap (-2.8%)
forEach over 50 elements 3,348 ops/sec [3,238..3,501] → 3,383 ops/sec [3,331..3,443] ~ overlap (+1.1%) 5,640 ops/sec [5,607..5,648] → 5,636 ops/sec [5,539..5,663] ~ overlap (-0.1%)
find in 50 elements 4,419 ops/sec [4,346..5,041] → 4,684 ops/sec [4,621..4,709] ~ overlap (+6.0%) 7,157 ops/sec [7,108..7,221] → 7,264 ops/sec [7,112..7,279] ~ overlap (+1.5%)
sort 20 elements 2,631 ops/sec [2,617..3,064] → 2,738 ops/sec [2,726..2,759] ~ overlap (+4.1%) 4,739 ops/sec [4,704..4,763] → 4,712 ops/sec [4,659..4,723] ~ overlap (-0.6%)
flat nested array 45,946 ops/sec [39,153..47,003] → 41,704 ops/sec [41,377..49,621] ~ overlap (-9.2%) 44,743 ops/sec [43,371..50,536] → 44,264 ops/sec [43,963..50,933] ~ overlap (-1.1%)
flatMap 18,086 ops/sec [16,959..20,372] → 18,260 ops/sec [18,139..18,350] ~ overlap (+1.0%) 22,457 ops/sec [22,148..23,798] → 23,508 ops/sec [22,773..25,267] ~ overlap (+4.7%)
map inside map (5x5) 4,235 ops/sec [4,030..5,071] → 4,377 ops/sec [4,352..4,691] ~ overlap (+3.4%) 5,848 ops/sec [5,791..6,064] → 5,954 ops/sec [5,911..5,984] ~ overlap (+1.8%)
filter inside map (5x10) 2,721 ops/sec [2,700..2,814] → 2,772 ops/sec [2,699..2,786] ~ overlap (+1.9%) 4,299 ops/sec [4,020..4,489] → 4,190 ops/sec [4,158..4,289] ~ overlap (-2.5%)
reduce inside map (5x10) 2,868 ops/sec [2,855..2,879] → 2,918 ops/sec [2,859..2,960] ~ overlap (+1.8%) 4,295 ops/sec [4,251..4,359] → 4,494 ops/sec [4,305..4,918] ~ overlap (+4.6%)
forEach inside forEach (5x10) 2,807 ops/sec [2,766..2,832] → 2,847 ops/sec [2,778..3,204] ~ overlap (+1.4%) 4,754 ops/sec [4,744..4,772] → 4,575 ops/sec [4,443..4,590] 🔴 -3.8%
find inside some (10x10) 2,091 ops/sec [2,016..2,309] → 2,339 ops/sec [2,105..2,434] ~ overlap (+11.9%) 3,445 ops/sec [3,272..3,576] → 3,221 ops/sec [3,153..3,238] 🔴 -6.5%
map+filter chain nested (5x20) 801 ops/sec [766..1,086] → 878 ops/sec [823..924] ~ overlap (+9.7%) 1,311 ops/sec [1,221..1,318] → 1,239 ops/sec [1,218..1,269] ~ overlap (-5.5%)
reduce flatten (10x5) 8,059 ops/sec [7,798..8,122] → 8,418 ops/sec [8,379..8,448] 🟢 +4.5% 4,220 ops/sec [4,111..4,756] → 4,005 ops/sec [3,975..4,153] ~ overlap (-5.1%)
async-await.js — Interp: 🟢 1, 5 unch. · avg +5.6% · Bytecode: 🔴 1, 5 unch. · avg -21.0%
Benchmark Interpreted Δ Bytecode Δ
single await 23,524 ops/sec [22,061..25,045] → 24,757 ops/sec [20,643..28,531] ~ overlap (+5.2%) 24,223 ops/sec [15,501..25,703] → 15,508 ops/sec [13,563..18,465] ~ overlap (-36.0%)
multiple awaits 9,254 ops/sec [9,165..9,278] → 10,017 ops/sec [9,671..13,249] 🟢 +8.2% 8,351 ops/sec [8,230..11,396] → 5,960 ops/sec [4,736..8,455] ~ overlap (-28.6%)
await non-Promise value 30,865 ops/sec [29,546..40,967] → 32,514 ops/sec [31,579..35,993] ~ overlap (+5.3%) 32,149 ops/sec [31,440..42,935] → 21,008 ops/sec [16,914..31,686] ~ overlap (-34.7%)
await with try/catch 20,132 ops/sec [19,030..21,576] → 21,601 ops/sec [20,155..22,721] ~ overlap (+7.3%) 24,977 ops/sec [19,941..25,573] → 22,758 ops/sec [21,066..23,349] ~ overlap (-8.9%)
await Promise.all 5,745 ops/sec [5,551..5,906] → 5,712 ops/sec [5,532..6,091] ~ overlap (-0.6%) 6,089 ops/sec [5,900..6,163] → 5,172 ops/sec [4,881..5,749] 🔴 -15.0%
nested async function call 12,726 ops/sec [12,553..13,407] → 13,778 ops/sec [12,763..15,621] ~ overlap (+8.3%) 13,516 ops/sec [13,029..14,646] → 13,167 ops/sec [10,964..13,474] ~ overlap (-2.6%)
async-generators.js — Interp: 🟢 1, 1 unch. · avg +4.5% · Bytecode: 🔴 2 · avg -25.7%
Benchmark Interpreted Δ Bytecode Δ
for-await-of over async generator 1,564 ops/sec [1,381..1,866] → 1,610 ops/sec [1,308..1,988] ~ overlap (+3.0%) 591 ops/sec [568..605] → 462 ops/sec [298..561] 🔴 -21.9%
async generator with await in body 10,355 ops/sec [10,289..10,395] → 10,987 ops/sec [10,903..11,037] 🟢 +6.1% 4,268 ops/sec [4,125..4,371] → 3,007 ops/sec [2,943..3,793] 🔴 -29.5%
atomics.js — Interp: 🆕 6 · Bytecode: 🆕 6
Benchmark Interpreted Δ Bytecode Δ
load and store Int32Array 81,789 ops/sec [80,796..83,178] 🆕 117,809 ops/sec [86,919..129,267] 🆕
read-modify-write Int32Array 56,801 ops/sec [56,530..58,020] 🆕 79,770 ops/sec [69,005..87,045] 🆕
compareExchange hit and miss 51,199 ops/sec [49,540..61,788] 🆕 71,120 ops/sec [68,832..73,987] 🆕
wait with zero timeout 126,098 ops/sec [122,909..142,081] 🆕 185,482 ops/sec [179,595..188,230] 🆕
waitAsync synchronous not-equal 91,377 ops/sec [90,103..110,169] 🆕 116,975 ops/sec [112,793..120,548] 🆕
notify with no waiters 136,133 ops/sec [129,584..174,309] 🆕 185,168 ops/sec [182,843..188,584] 🆕
base64.js — Interp: 🟢 1, 9 unch. · avg +3.1% · Bytecode: 🔴 1, 9 unch. · avg -1.0%
Benchmark Interpreted Δ Bytecode Δ
short ASCII (13 chars) 2,057 ops/sec [1,572..2,274] → 2,175 ops/sec [2,151..2,223] ~ overlap (+5.7%) 2,011 ops/sec [2,005..2,014] → 2,047 ops/sec [1,993..2,063] ~ overlap (+1.8%)
medium ASCII (450 chars) 74 ops/sec [71..116] → 76 ops/sec [75..76] ~ overlap (+3.2%) 73 ops/sec [72..78] → 73 ops/sec [71..74] ~ overlap (-0.6%)
Latin-1 characters 3,029 ops/sec [2,963..3,746] → 3,211 ops/sec [3,200..3,217] ~ overlap (+6.0%) 2,994 ops/sec [2,978..3,123] → 3,002 ops/sec [2,904..3,360] ~ overlap (+0.3%)
short base64 (20 chars) 1,670 ops/sec [1,547..1,779] → 1,655 ops/sec [1,649..1,666] ~ overlap (-0.9%) 1,586 ops/sec [1,572..2,033] → 1,555 ops/sec [1,536..1,579] ~ overlap (-2.0%)
medium base64 (600 chars) 62 ops/sec [61..79] → 64 ops/sec [63..64] ~ overlap (+3.9%) 66 ops/sec [60..70] → 61 ops/sec [61..61] ~ overlap (-7.5%)
Latin-1 output 2,440 ops/sec [2,282..2,832] → 2,412 ops/sec [2,400..2,646] ~ overlap (-1.1%) 2,324 ops/sec [2,297..2,393] → 2,272 ops/sec [2,237..2,285] 🔴 -2.2%
forgiving (no padding) 3,447 ops/sec [3,428..3,484] → 3,676 ops/sec [3,527..3,735] 🟢 +6.6% 3,321 ops/sec [3,306..3,360] → 3,416 ops/sec [3,164..3,708] ~ overlap (+2.9%)
with whitespace 1,467 ops/sec [1,451..1,488] → 1,496 ops/sec [1,484..1,531] ~ overlap (+2.0%) 1,447 ops/sec [1,433..1,450] → 1,450 ops/sec [1,441..1,462] ~ overlap (+0.2%)
atob(btoa(short)) 975 ops/sec [905..1,024] → 918 ops/sec [904..945] ~ overlap (-5.9%) 897 ops/sec [869..925] → 887 ops/sec [880..888] ~ overlap (-1.1%)
atob(btoa(medium)) 36 ops/sec [33..38] → 40 ops/sec [35..42] ~ overlap (+11.6%) 34 ops/sec [33..36] → 34 ops/sec [32..36] ~ overlap (-1.7%)
classes.js — Interp: 🟢 11, 20 unch. · avg +5.2% · Bytecode: 🟢 2, 🔴 1, 28 unch. · avg -0.4%
Benchmark Interpreted Δ Bytecode Δ
simple class new 39,001 ops/sec [38,611..39,757] → 40,417 ops/sec [39,910..41,523] 🟢 +3.6% 53,033 ops/sec [52,506..53,192] → 51,523 ops/sec [50,772..52,151] 🔴 -2.8%
class with defaults 30,130 ops/sec [29,862..32,397] → 34,528 ops/sec [31,476..37,017] ~ overlap (+14.6%) 34,325 ops/sec [33,871..38,133] → 35,096 ops/sec [34,266..35,656] ~ overlap (+2.2%)
50 instances via Array.from 1,177 ops/sec [1,171..1,193] → 1,247 ops/sec [1,219..1,267] 🟢 +5.9% 1,523 ops/sec [1,508..1,583] → 1,610 ops/sec [1,599..1,612] 🟢 +5.7%
instance method call 17,592 ops/sec [17,293..19,640] → 18,370 ops/sec [17,804..18,539] ~ overlap (+4.4%) 26,399 ops/sec [20,462..26,835] → 27,552 ops/sec [27,403..27,606] 🟢 +4.4%
static method call 29,437 ops/sec [29,051..30,222] → 31,337 ops/sec [30,372..31,717] 🟢 +6.5% 56,320 ops/sec [53,902..60,252] → 54,539 ops/sec [53,896..56,745] ~ overlap (-3.2%)
single-level inheritance 15,662 ops/sec [15,272..19,813] → 16,412 ops/sec [16,146..16,534] ~ overlap (+4.8%) 19,224 ops/sec [19,012..20,981] → 19,065 ops/sec [18,867..20,293] ~ overlap (-0.8%)
two-level inheritance 13,747 ops/sec [13,530..14,379] → 14,416 ops/sec [13,764..15,204] ~ overlap (+4.9%) 15,006 ops/sec [14,773..15,264] → 14,821 ops/sec [14,577..14,993] ~ overlap (-1.2%)
private field access 19,324 ops/sec [19,069..19,446] → 19,925 ops/sec [19,572..21,712] 🟢 +3.1% 14,740 ops/sec [14,575..15,697] → 14,524 ops/sec [14,439..14,746] ~ overlap (-1.5%)
private methods 21,736 ops/sec [21,599..21,812] → 22,740 ops/sec [22,545..22,899] 🟢 +4.6% 16,478 ops/sec [16,181..16,621] → 16,301 ops/sec [16,200..17,118] ~ overlap (-1.1%)
getter/setter access 20,772 ops/sec [20,393..21,963] → 21,901 ops/sec [21,724..23,587] ~ overlap (+5.4%) 29,114 ops/sec [28,699..29,543] → 29,385 ops/sec [28,394..30,042] ~ overlap (+0.9%)
class decorator (identity) 29,947 ops/sec [29,510..30,234] → 31,987 ops/sec [31,861..32,201] 🟢 +6.8% 33,062 ops/sec [32,555..45,940] → 32,719 ops/sec [31,898..35,558] ~ overlap (-1.0%)
class decorator (wrapping) 17,054 ops/sec [16,592..21,997] → 18,272 ops/sec [18,141..30,386] ~ overlap (+7.1%) 17,304 ops/sec [16,521..19,138] → 17,232 ops/sec [16,599..19,045] ~ overlap (-0.4%)
identity method decorator 21,140 ops/sec [19,556..26,563] → 24,912 ops/sec [22,476..31,199] ~ overlap (+17.8%) 30,397 ops/sec [26,971..33,970] → 27,220 ops/sec [26,281..28,928] ~ overlap (-10.4%)
wrapping method decorator 19,110 ops/sec [16,570..21,852] → 17,769 ops/sec [17,504..18,930] ~ overlap (-7.0%) 20,670 ops/sec [20,279..20,875] → 20,146 ops/sec [19,974..21,125] ~ overlap (-2.5%)
stacked method decorators (x3) 12,257 ops/sec [10,760..13,470] → 14,419 ops/sec [12,695..18,464] ~ overlap (+17.6%) 15,217 ops/sec [14,971..15,279] → 14,756 ops/sec [14,562..16,260] ~ overlap (-3.0%)
identity field decorator 27,138 ops/sec [25,027..32,502] → 27,219 ops/sec [26,757..29,194] ~ overlap (+0.3%) 26,731 ops/sec [26,147..30,037] → 26,406 ops/sec [25,932..26,626] ~ overlap (-1.2%)
field initializer decorator 21,954 ops/sec [20,277..24,237] → 21,184 ops/sec [20,843..21,942] ~ overlap (-3.5%) 22,957 ops/sec [22,843..23,307] → 22,670 ops/sec [22,508..25,963] ~ overlap (-1.3%)
getter decorator (identity) 19,595 ops/sec [19,057..22,569] → 21,731 ops/sec [20,012..23,779] ~ overlap (+10.9%) 18,358 ops/sec [18,176..19,203] → 18,171 ops/sec [17,431..18,983] ~ overlap (-1.0%)
setter decorator (identity) 15,702 ops/sec [15,573..15,928] → 17,960 ops/sec [16,056..20,260] 🟢 +14.4% 14,709 ops/sec [14,545..16,007] → 14,670 ops/sec [14,342..14,885] ~ overlap (-0.3%)
static method decorator 21,828 ops/sec [21,592..23,244] → 23,392 ops/sec [23,113..25,155] ~ overlap (+7.2%) 30,842 ops/sec [29,952..38,689] → 29,816 ops/sec [28,851..30,216] ~ overlap (-3.3%)
static field decorator 27,597 ops/sec [27,394..27,627] → 28,556 ops/sec [28,291..28,763] 🟢 +3.5% 33,989 ops/sec [33,154..37,339] → 33,413 ops/sec [32,075..37,729] ~ overlap (-1.7%)
private method decorator 16,312 ops/sec [16,238..16,460] → 18,300 ops/sec [16,768..19,490] 🟢 +12.2% 20,084 ops/sec [19,252..20,298] → 19,338 ops/sec [18,632..21,225] ~ overlap (-3.7%)
private field decorator 19,278 ops/sec [19,131..22,875] → 20,273 ops/sec [20,132..20,778] ~ overlap (+5.2%) 18,360 ops/sec [18,099..18,571] → 19,671 ops/sec [17,229..21,468] ~ overlap (+7.1%)
plain auto-accessor (no decorator) 35,275 ops/sec [34,958..37,710] → 35,548 ops/sec [35,513..35,794] ~ overlap (+0.8%) 33,983 ops/sec [33,625..34,162] → 35,137 ops/sec [32,733..38,654] ~ overlap (+3.4%)
auto-accessor with decorator 18,898 ops/sec [17,890..22,382] → 19,503 ops/sec [19,365..19,553] ~ overlap (+3.2%) 20,672 ops/sec [20,468..24,346] → 21,318 ops/sec [18,836..24,239] ~ overlap (+3.1%)
decorator writing metadata 14,301 ops/sec [13,773..14,375] → 15,056 ops/sec [14,959..15,096] 🟢 +5.3% 18,764 ops/sec [18,159..21,927] → 17,937 ops/sec [16,993..20,048] ~ overlap (-4.4%)
static getter read 36,121 ops/sec [35,718..36,288] → 39,508 ops/sec [39,323..39,543] 🟢 +9.4% 50,739 ops/sec [50,370..53,301] → 52,905 ops/sec [50,354..54,901] ~ overlap (+4.3%)
static getter/setter pair 25,762 ops/sec [25,282..26,965] → 26,012 ops/sec [25,871..28,275] ~ overlap (+1.0%) 37,952 ops/sec [37,277..41,284] → 37,401 ops/sec [36,418..38,113] ~ overlap (-1.5%)
inherited static getter 23,738 ops/sec [23,686..25,316] → 24,578 ops/sec [24,001..24,882] ~ overlap (+3.5%) 36,644 ops/sec [32,943..40,893] → 35,025 ops/sec [32,177..38,084] ~ overlap (-4.4%)
inherited static setter 26,737 ops/sec [24,678..27,880] → 25,076 ops/sec [24,578..29,988] ~ overlap (-6.2%) 34,327 ops/sec [33,095..36,400] → 35,004 ops/sec [30,573..38,894] ~ overlap (+2.0%)
inherited static getter with this binding 20,881 ops/sec [18,607..21,248] → 19,419 ops/sec [19,194..20,421] ~ overlap (-7.0%) 26,538 ops/sec [25,739..28,190] → 28,053 ops/sec [25,007..30,246] ~ overlap (+5.7%)
closures.js — Interp: 🟢 4, 7 unch. · avg +4.5% · Bytecode: 11 unch. · avg +0.7%
Benchmark Interpreted Δ Bytecode Δ
closure over single variable 25,930 ops/sec [25,499..26,173] → 27,378 ops/sec [27,250..31,589] 🟢 +5.6% 87,621 ops/sec [86,812..90,119] → 87,790 ops/sec [85,426..91,471] ~ overlap (+0.2%)
closure over multiple variables 28,768 ops/sec [28,356..28,871] → 30,751 ops/sec [30,533..32,507] 🟢 +6.9% 82,557 ops/sec [80,797..84,299] → 86,255 ops/sec [79,743..96,023] ~ overlap (+4.5%)
nested closures 32,349 ops/sec [30,818..36,436] → 34,858 ops/sec [34,698..35,146] ~ overlap (+7.8%) 82,858 ops/sec [81,046..83,228] → 81,740 ops/sec [80,037..101,856] ~ overlap (-1.3%)
function as argument 19,933 ops/sec [19,717..20,425] → 21,419 ops/sec [21,225..25,428] 🟢 +7.5% 75,339 ops/sec [73,018..75,659] → 74,445 ops/sec [73,744..75,948] ~ overlap (-1.2%)
function returning function 27,272 ops/sec [26,444..27,916] → 28,821 ops/sec [28,472..28,913] 🟢 +5.7% 87,983 ops/sec [87,679..88,331] → 87,218 ops/sec [86,161..90,392] ~ overlap (-0.9%)
compose two functions 16,765 ops/sec [16,270..18,775] → 17,910 ops/sec [17,844..18,056] ~ overlap (+6.8%) 51,918 ops/sec [50,890..58,515] → 51,435 ops/sec [50,990..51,739] ~ overlap (-0.9%)
fn.call 42,125 ops/sec [39,933..43,695] → 42,870 ops/sec [42,530..44,626] ~ overlap (+1.8%) 68,571 ops/sec [65,570..93,871] → 68,619 ops/sec [68,096..70,555] ~ overlap (+0.1%)
fn.apply 31,490 ops/sec [31,244..45,440] → 32,801 ops/sec [32,362..33,360] ~ overlap (+4.2%) 67,270 ops/sec [64,251..71,557] → 74,644 ops/sec [65,580..106,840] ~ overlap (+11.0%)
fn.bind 35,086 ops/sec [33,273..36,948] → 36,208 ops/sec [36,009..38,099] ~ overlap (+3.2%) 90,028 ops/sec [89,196..90,582] → 89,794 ops/sec [87,881..133,896] ~ overlap (-0.3%)
recursive sum to 50 2,733 ops/sec [2,416..3,253] → 2,633 ops/sec [2,513..3,577] ~ overlap (-3.6%) 10,718 ops/sec [10,499..10,766] → 10,551 ops/sec [10,489..10,683] ~ overlap (-1.6%)
recursive tree traversal 4,327 ops/sec [4,300..4,903] → 4,507 ops/sec [4,428..4,641] ~ overlap (+4.1%) 10,794 ops/sec [10,372..12,750] → 10,579 ops/sec [10,494..10,957] ~ overlap (-2.0%)
collections.js — Interp: 🟢 5, 7 unch. · avg +8.3% · Bytecode: 12 unch. · avg -3.0%
Benchmark Interpreted Δ Bytecode Δ
add 50 elements 2,144 ops/sec [2,048..2,256] → 2,172 ops/sec [2,125..2,419] ~ overlap (+1.3%) 2,613 ops/sec [2,557..2,895] → 2,530 ops/sec [2,500..2,642] ~ overlap (-3.2%)
has lookup (50 elements) 36,273 ops/sec [35,578..39,791] → 39,649 ops/sec [39,284..42,268] ~ overlap (+9.3%) 46,633 ops/sec [45,203..53,183] → 46,528 ops/sec [46,247..46,617] ~ overlap (-0.2%)
delete elements 20,250 ops/sec [19,728..20,551] → 22,333 ops/sec [22,150..22,441] 🟢 +10.3% 24,526 ops/sec [24,428..25,119] → 24,465 ops/sec [24,248..24,684] ~ overlap (-0.2%)
forEach iteration 3,367 ops/sec [3,226..3,414] → 3,569 ops/sec [3,507..3,607] 🟢 +6.0% 6,345 ops/sec [5,897..6,619] → 6,229 ops/sec [5,840..6,878] ~ overlap (-1.8%)
spread to array 11,688 ops/sec [10,340..12,560] → 12,566 ops/sec [12,131..16,296] ~ overlap (+7.5%) 75,512 ops/sec [70,353..88,165] → 70,721 ops/sec [70,141..71,240] ~ overlap (-6.3%)
deduplicate array 16,833 ops/sec [15,918..20,297] → 18,559 ops/sec [18,228..28,758] ~ overlap (+10.3%) 31,677 ops/sec [30,791..33,130] → 30,513 ops/sec [29,484..32,855] ~ overlap (-3.7%)
set 50 entries 1,597 ops/sec [1,565..1,654] → 1,735 ops/sec [1,697..1,796] 🟢 +8.6% 2,070 ops/sec [2,042..2,649] → 2,032 ops/sec [1,936..2,048] ~ overlap (-1.8%)
get lookup (50 entries) 36,799 ops/sec [34,730..53,348] → 39,174 ops/sec [38,958..50,990] ~ overlap (+6.5%) 42,212 ops/sec [41,463..43,717] → 41,225 ops/sec [40,540..44,849] ~ overlap (-2.3%)
has check 49,746 ops/sec [49,001..50,816] → 59,180 ops/sec [54,025..66,827] 🟢 +19.0% 64,218 ops/sec [61,324..77,228] → 62,913 ops/sec [60,887..64,462] ~ overlap (-2.0%)
delete entries 20,310 ops/sec [20,153..20,501] → 22,042 ops/sec [21,761..27,995] 🟢 +8.5% 23,124 ops/sec [22,900..23,706] → 22,957 ops/sec [22,743..23,965] ~ overlap (-0.7%)
forEach iteration 3,291 ops/sec [3,227..3,493] → 3,461 ops/sec [3,430..4,304] ~ overlap (+5.2%) 6,042 ops/sec [5,783..6,203] → 5,949 ops/sec [5,943..6,061] ~ overlap (-1.5%)
keys/values/entries 3,300 ops/sec [3,200..3,539] → 3,531 ops/sec [3,368..4,436] ~ overlap (+7.0%) 13,138 ops/sec [11,882..13,781] → 11,499 ops/sec [10,935..13,392] ~ overlap (-12.5%)
csv.js — Interp: 🟢 3, 🔴 1, 9 unch. · avg +3.3% · Bytecode: 🟢 1, 🔴 1, 11 unch. · avg +0.5%
Benchmark Interpreted Δ Bytecode Δ
parse simple 3-column CSV 39,058 ops/sec [38,311..43,251] → 40,035 ops/sec [39,916..40,361] ~ overlap (+2.5%) 45,319 ops/sec [42,730..49,531] → 49,035 ops/sec [42,372..55,593] ~ overlap (+8.2%)
parse 10-row CSV 11,449 ops/sec [10,623..12,523] → 11,569 ops/sec [11,406..12,243] ~ overlap (+1.1%) 11,810 ops/sec [11,657..11,934] → 12,233 ops/sec [11,742..14,719] ~ overlap (+3.6%)
parse 100-row CSV 1,816 ops/sec [1,748..2,022] → 2,248 ops/sec [2,186..2,299] 🟢 +23.8% 1,858 ops/sec [1,808..1,905] → 1,823 ops/sec [1,649..2,023] ~ overlap (-1.9%)
parse CSV with quoted fields 55,532 ops/sec [51,290..63,935] → 64,385 ops/sec [61,494..69,446] ~ overlap (+15.9%) 63,240 ops/sec [62,934..77,206] → 62,482 ops/sec [62,377..63,052] ~ overlap (-1.2%)
parse without headers (array of arrays) 5,579 ops/sec [5,337..5,998] → 5,807 ops/sec [5,422..10,166] ~ overlap (+4.1%) 5,612 ops/sec [5,550..5,728] → 5,522 ops/sec [5,409..6,474] ~ overlap (-1.6%)
parse with semicolon delimiter 9,451 ops/sec [8,710..11,617] → 8,380 ops/sec [8,228..9,932] ~ overlap (-11.3%) 8,773 ops/sec [8,718..9,154] → 8,545 ops/sec [8,346..9,594] ~ overlap (-2.6%)
stringify array of objects 53,443 ops/sec [52,715..62,381] → 54,367 ops/sec [51,024..68,439] ~ overlap (+1.7%) 62,003 ops/sec [61,257..62,806] → 63,331 ops/sec [63,134..63,636] 🟢 +2.1%
stringify array of arrays 21,769 ops/sec [21,329..22,025] → 22,016 ops/sec [21,781..22,248] ~ overlap (+1.1%) 23,670 ops/sec [23,311..24,166] → 23,510 ops/sec [22,976..28,757] ~ overlap (-0.7%)
stringify with values needing escaping 42,301 ops/sec [41,983..42,859] → 42,352 ops/sec [41,478..42,571] ~ overlap (+0.1%) 48,078 ops/sec [47,507..51,785] → 49,181 ops/sec [47,002..61,522] ~ overlap (+2.3%)
reviver converts numbers 820 ops/sec [806..822] → 840 ops/sec [830..1,122] 🟢 +2.4% 1,078 ops/sec [1,049..1,085] → 1,074 ops/sec [1,069..1,076] ~ overlap (-0.3%)
reviver filters empty to null 6,777 ops/sec [6,727..6,789] → 7,221 ops/sec [6,925..7,856] 🟢 +6.5% 10,085 ops/sec [9,995..10,111] → 10,717 ops/sec [9,580..11,356] ~ overlap (+6.3%)
parse then stringify 7,625 ops/sec [7,287..8,046] → 7,606 ops/sec [7,507..7,688] ~ overlap (-0.3%) 7,872 ops/sec [7,701..7,960] → 7,628 ops/sec [7,561..7,702] ~ overlap (-3.1%)
stringify then parse 7,422 ops/sec [7,318..8,221] → 7,104 ops/sec [7,046..7,132] 🔴 -4.3% 7,783 ops/sec [7,722..7,832] → 7,465 ops/sec [7,379..7,547] 🔴 -4.1%
destructuring.js — Interp: 🟢 5, 🔴 3, 14 unch. · avg +0.7% · Bytecode: 🟢 1, 🔴 6, 15 unch. · avg -1.0%
Benchmark Interpreted Δ Bytecode Δ
simple array destructuring 64,487 ops/sec [63,289..67,272] → 65,387 ops/sec [64,651..72,732] ~ overlap (+1.4%) 83,202 ops/sec [82,031..83,710] → 93,405 ops/sec [90,955..95,208] 🟢 +12.3%
with rest element 54,832 ops/sec [53,542..55,971] → 54,642 ops/sec [54,576..65,696] ~ overlap (-0.3%) 67,450 ops/sec [66,424..74,989] → 82,583 ops/sec [66,619..84,672] ~ overlap (+22.4%)
with defaults 69,777 ops/sec [64,100..84,665] → 66,444 ops/sec [65,925..70,467] ~ overlap (-4.8%) 90,116 ops/sec [87,919..90,367] → 88,383 ops/sec [87,704..88,663] ~ overlap (-1.9%)
skip elements 72,278 ops/sec [71,300..72,329] → 74,866 ops/sec [73,773..77,541] 🟢 +3.6% 91,430 ops/sec [90,527..93,325] → 89,092 ops/sec [88,547..89,427] 🔴 -2.6%
nested array destructuring 31,144 ops/sec [30,860..31,364] → 31,904 ops/sec [31,742..32,045] 🟢 +2.4% 32,638 ops/sec [31,950..32,688] → 31,065 ops/sec [30,972..31,139] 🔴 -4.8%
swap variables 88,091 ops/sec [87,673..88,249] → 91,462 ops/sec [89,908..96,734] 🟢 +3.8% 121,521 ops/sec [116,048..135,557] → 118,145 ops/sec [117,303..118,651] ~ overlap (-2.8%)
simple object destructuring 77,642 ops/sec [76,743..78,263] → 76,055 ops/sec [75,718..76,443] 🔴 -2.0% 91,319 ops/sec [90,390..93,005] → 92,031 ops/sec [89,781..95,403] ~ overlap (+0.8%)
with defaults 85,919 ops/sec [83,454..87,398] → 88,029 ops/sec [86,772..89,190] ~ overlap (+2.5%) 135,822 ops/sec [135,165..136,374] → 140,289 ops/sec [130,629..149,781] ~ overlap (+3.3%)
with renaming 85,184 ops/sec [83,200..86,554] → 88,949 ops/sec [84,725..89,195] ~ overlap (+4.4%) 100,259 ops/sec [97,229..108,798] → 98,675 ops/sec [95,955..99,804] ~ overlap (-1.6%)
nested object destructuring 46,054 ops/sec [45,777..46,176] → 47,634 ops/sec [47,408..47,729] 🟢 +3.4% 50,283 ops/sec [49,678..52,378] → 49,783 ops/sec [49,102..51,477] ~ overlap (-1.0%)
rest properties 37,400 ops/sec [36,021..40,992] → 35,676 ops/sec [35,605..35,767] 🔴 -4.6% 47,842 ops/sec [43,372..58,181] → 51,553 ops/sec [46,650..53,932] ~ overlap (+7.8%)
object parameter 23,602 ops/sec [23,444..24,156] → 25,023 ops/sec [24,805..25,248] 🟢 +6.0% 42,336 ops/sec [41,545..63,771] → 42,095 ops/sec [40,636..60,363] ~ overlap (-0.6%)
array parameter 26,288 ops/sec [25,531..26,524] → 27,038 ops/sec [25,972..28,543] ~ overlap (+2.9%) 42,072 ops/sec [41,249..43,276] → 40,715 ops/sec [39,895..52,774] ~ overlap (-3.2%)
mixed destructuring in map 6,104 ops/sec [5,946..6,176] → 6,132 ops/sec [6,106..6,173] ~ overlap (+0.4%) 10,913 ops/sec [10,871..11,388] → 10,437 ops/sec [10,328..10,518] 🔴 -4.4%
forEach with array destructuring 13,468 ops/sec [13,432..13,541] → 12,681 ops/sec [12,572..12,931] 🔴 -5.8% 15,425 ops/sec [15,228..15,595] → 15,034 ops/sec [14,807..21,345] ~ overlap (-2.5%)
map with array destructuring 13,106 ops/sec [12,961..14,332] → 13,384 ops/sec [13,270..13,785] ~ overlap (+2.1%) 14,925 ops/sec [14,825..15,147] → 14,182 ops/sec [13,607..14,444] 🔴 -5.0%
filter with array destructuring 13,553 ops/sec [13,381..15,454] → 14,065 ops/sec [13,874..18,330] ~ overlap (+3.8%) 16,062 ops/sec [15,784..20,629] → 15,116 ops/sec [14,806..15,180] 🔴 -5.9%
reduce with array destructuring 13,745 ops/sec [13,512..15,296] → 14,370 ops/sec [14,232..14,827] ~ overlap (+4.5%) 17,267 ops/sec [16,252..18,373] → 14,354 ops/sec [13,846..15,690] 🔴 -16.9%
map with object destructuring 13,789 ops/sec [13,237..14,061] → 14,067 ops/sec [13,916..14,401] ~ overlap (+2.0%) 21,963 ops/sec [21,121..23,516] → 21,642 ops/sec [20,496..22,167] ~ overlap (-1.5%)
map with nested destructuring 12,436 ops/sec [11,668..14,813] → 11,749 ops/sec [11,680..11,808] ~ overlap (-5.5%) 21,184 ops/sec [20,926..27,958] → 20,307 ops/sec [19,583..21,218] ~ overlap (-4.1%)
map with rest in destructuring 7,244 ops/sec [7,034..9,005] → 7,329 ops/sec [7,295..7,429] ~ overlap (+1.2%) 8,466 ops/sec [8,434..8,483] → 8,304 ops/sec [7,741..8,805] ~ overlap (-1.9%)
map with defaults in destructuring 10,055 ops/sec [9,185..10,944] → 9,555 ops/sec [9,543..9,575] ~ overlap (-5.0%) 18,382 ops/sec [16,805..18,510] → 16,968 ops/sec [16,745..17,098] ~ overlap (-7.7%)
fibonacci.js — Interp: 🟢 3, 5 unch. · avg +4.6% · Bytecode: 🔴 2, 6 unch. · avg -3.0%
Benchmark Interpreted Δ Bytecode Δ
recursive fib(15) 67 ops/sec [65..68] → 73 ops/sec [71..74] 🟢 +9.9% 289 ops/sec [282..309] → 284 ops/sec [281..288] ~ overlap (-1.6%)
recursive fib(20) 7 ops/sec [6..7] → 7 ops/sec [7..8] 🟢 +7.6% 27 ops/sec [25..29] → 28 ops/sec [26..31] ~ overlap (+5.6%)
recursive fib(15) typed 68 ops/sec [67..68] → 72 ops/sec [71..84] 🟢 +6.2% 316 ops/sec [294..375] → 288 ops/sec [283..291] 🔴 -8.9%
recursive fib(20) typed 7 ops/sec [6..7] → 7 ops/sec [7..7] ~ overlap (+4.2%) 28 ops/sec [26..29] → 28 ops/sec [26..29] ~ overlap (-3.0%)
iterative fib(20) via reduce 3,437 ops/sec [3,272..3,723] → 3,582 ops/sec [3,553..3,597] ~ overlap (+4.2%) 6,017 ops/sec [5,877..6,283] → 5,895 ops/sec [5,605..5,910] ~ overlap (-2.0%)
iterator fib(20) 2,253 ops/sec [2,249..2,258] → 2,328 ops/sec [2,246..2,341] ~ overlap (+3.3%) 5,027 ops/sec [4,805..5,513] → 4,627 ops/sec [4,572..4,767] 🔴 -7.9%
iterator fib(20) via Iterator.from + take 2,114 ops/sec [1,975..2,190] → 2,157 ops/sec [2,002..2,167] ~ overlap (+2.0%) 2,913 ops/sec [2,647..3,552] → 2,676 ops/sec [2,466..2,705] ~ overlap (-8.1%)
iterator fib(20) last value via reduce 1,680 ops/sec [1,659..1,687] → 1,666 ops/sec [1,657..1,680] ~ overlap (-0.8%) 2,205 ops/sec [2,202..2,227] → 2,245 ops/sec [2,202..2,323] ~ overlap (+1.8%)
float16array.js — Interp: 🟢 9, 🔴 2, 21 unch. · avg +2.8% · Bytecode: 🟢 5, 🔴 1, 26 unch. · avg +2.3%
Benchmark Interpreted Δ Bytecode Δ
new Float16Array(0) 90,996 ops/sec [90,214..94,128] → 94,189 ops/sec [90,677..103,254] ~ overlap (+3.5%) 108,461 ops/sec [108,007..112,362] → 110,369 ops/sec [109,784..111,346] ~ overlap (+1.8%)
new Float16Array(100) 87,918 ops/sec [85,529..109,586] → 93,033 ops/sec [91,752..98,602] ~ overlap (+5.8%) 106,544 ops/sec [105,884..106,679] → 102,154 ops/sec [100,463..108,337] ~ overlap (-4.1%)
new Float16Array(1000) 77,844 ops/sec [76,265..78,295] → 84,348 ops/sec [83,964..84,912] 🟢 +8.4% 91,712 ops/sec [90,810..111,258] → 90,159 ops/sec [87,211..91,527] ~ overlap (-1.7%)
Float16Array.from([...100]) 1,496 ops/sec [1,445..1,593] → 1,620 ops/sec [1,564..1,628] ~ overlap (+8.3%) 1,793 ops/sec [1,493..2,095] → 1,532 ops/sec [1,521..1,548] ~ overlap (-14.6%)
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5) 70,490 ops/sec [70,046..70,734] → 72,964 ops/sec [71,046..75,834] 🟢 +3.5% 67,935 ops/sec [67,078..72,704] → 69,443 ops/sec [68,290..72,314] ~ overlap (+2.2%)
new Float16Array(float64Array) 24,596 ops/sec [24,430..25,330] → 24,874 ops/sec [22,559..26,126] ~ overlap (+1.1%) 26,168 ops/sec [26,087..26,180] → 27,528 ops/sec [26,324..27,796] 🟢 +5.2%
sequential write 100 elements 720 ops/sec [709..725] → 777 ops/sec [776..838] 🟢 +8.0% 1,454 ops/sec [1,396..1,472] → 1,455 ops/sec [1,438..1,701] ~ overlap (+0.1%)
sequential read 100 elements 787 ops/sec [773..793] → 865 ops/sec [852..1,019] 🟢 +9.8% 1,654 ops/sec [1,644..1,658] → 1,593 ops/sec [1,577..1,604] 🔴 -3.6%
write special values (NaN, Inf, -0) 21,542 ops/sec [21,320..21,582] → 23,126 ops/sec [22,716..23,531] 🟢 +7.4% 27,650 ops/sec [27,302..33,801] → 28,666 ops/sec [28,295..28,900] ~ overlap (+3.7%)
Float16Array write 728 ops/sec [725..730] → 779 ops/sec [773..781] 🟢 +7.1% 1,437 ops/sec [1,411..1,448] → 1,462 ops/sec [1,446..1,681] ~ overlap (+1.7%)
Float32Array write 727 ops/sec [696..758] → 776 ops/sec [772..782] 🟢 +6.7% 1,456 ops/sec [1,325..1,462] → 1,569 ops/sec [1,424..1,603] ~ overlap (+7.8%)
Float64Array write 730 ops/sec [697..909] → 774 ops/sec [771..778] ~ overlap (+6.1%) 1,402 ops/sec [1,393..1,454] → 1,566 ops/sec [1,437..1,747] ~ overlap (+11.7%)
Float16Array read 771 ops/sec [741..884] → 829 ops/sec [821..835] ~ overlap (+7.5%) 1,540 ops/sec [1,502..1,552] → 1,703 ops/sec [1,560..1,886] 🟢 +10.6%
Float32Array read 795 ops/sec [749..830] → 816 ops/sec [780..823] ~ overlap (+2.7%) 1,532 ops/sec [1,489..1,567] → 1,604 ops/sec [1,534..1,790] ~ overlap (+4.7%)
Float64Array read 797 ops/sec [789..837] → 810 ops/sec [795..865] ~ overlap (+1.6%) 1,545 ops/sec [1,533..1,556] → 1,551 ops/sec [1,538..1,559] ~ overlap (+0.3%)
fill(1.5) 3,641 ops/sec [3,575..3,997] → 3,040 ops/sec [3,025..3,062] 🔴 -16.5% 3,763 ops/sec [3,737..4,373] → 4,025 ops/sec [3,634..4,695] ~ overlap (+7.0%)
slice() 9,859 ops/sec [9,693..10,279] → 9,935 ops/sec [9,252..10,269] ~ overlap (+0.8%) 10,184 ops/sec [9,916..14,381] → 10,937 ops/sec [10,743..10,960] ~ overlap (+7.4%)
map(x => x * 2) 1,424 ops/sec [1,401..1,428] → 1,504 ops/sec [1,462..1,527] 🟢 +5.6% 2,037 ops/sec [2,011..2,058] → 2,109 ops/sec [2,067..2,263] 🟢 +3.5%
filter(x => x > 25) 1,410 ops/sec [1,404..1,581] → 1,533 ops/sec [1,522..1,582] ~ overlap (+8.7%) 2,260 ops/sec [2,094..2,360] → 2,295 ops/sec [2,229..2,476] ~ overlap (+1.5%)
reduce (sum) 1,393 ops/sec [1,374..1,411] → 1,499 ops/sec [1,481..1,512] 🟢 +7.6% 1,923 ops/sec [1,921..1,994] → 2,020 ops/sec [2,011..2,038] 🟢 +5.0%
sort() 21,030 ops/sec [20,828..22,136] → 21,047 ops/sec [20,277..23,013] ~ overlap (+0.1%) 22,413 ops/sec [21,597..22,550] → 23,146 ops/sec [22,672..30,954] 🟢 +3.3%
indexOf() 24,437 ops/sec [24,422..24,465] → 24,439 ops/sec [23,835..24,598] ~ overlap (+0.0%) 26,728 ops/sec [25,239..28,452] → 26,619 ops/sec [26,186..30,620] ~ overlap (-0.4%)
reverse() 27,935 ops/sec [25,048..30,021] → 23,786 ops/sec [23,387..29,070] ~ overlap (-14.9%) 30,517 ops/sec [28,044..31,655] → 29,253 ops/sec [28,907..29,563] ~ overlap (-4.1%)
toReversed() 21,492 ops/sec [21,280..22,076] → 19,872 ops/sec [19,740..20,014] 🔴 -7.5% 22,437 ops/sec [21,997..22,717] → 22,382 ops/sec [22,171..22,629] ~ overlap (-0.2%)
toSorted() 6,022 ops/sec [5,979..6,070] → 5,930 ops/sec [5,870..6,409] ~ overlap (-1.5%) 6,037 ops/sec [5,934..6,208] → 6,149 ops/sec [6,081..6,231] ~ overlap (+1.9%)
create view over existing buffer 100,990 ops/sec [99,661..102,501] → 98,783 ops/sec [96,797..130,197] ~ overlap (-2.2%) 117,851 ops/sec [116,374..122,356] → 132,510 ops/sec [117,980..169,754] ~ overlap (+12.4%)
subarray() 59,431 ops/sec [58,537..60,884] → 60,348 ops/sec [60,087..60,663] ~ overlap (+1.5%) 65,643 ops/sec [64,295..77,601] → 67,730 ops/sec [66,434..76,392] ~ overlap (+3.2%)
set() from array 77,214 ops/sec [75,456..80,202] → 83,908 ops/sec [76,465..89,958] ~ overlap (+8.7%) 96,709 ops/sec [94,855..102,964] → 106,110 ops/sec [95,563..127,702] ~ overlap (+9.7%)
for-of loop 1,519 ops/sec [1,498..1,550] → 1,611 ops/sec [1,540..1,642] ~ overlap (+6.0%) 6,637 ops/sec [6,343..7,623] → 6,400 ops/sec [5,411..6,611] ~ overlap (-3.6%)
spread into array 6,184 ops/sec [5,949..7,284] → 6,296 ops/sec [6,185..8,565] ~ overlap (+1.8%) 22,669 ops/sec [22,624..22,782] → 23,182 ops/sec [22,641..29,318] ~ overlap (+2.3%)
f16round(1.337) 166,744 ops/sec [157,106..187,025] → 181,109 ops/sec [177,421..209,872] ~ overlap (+8.6%) 223,791 ops/sec [214,184..254,997] → 222,811 ops/sec [221,347..223,434] ~ overlap (-0.4%)
f16round over 100 values 1,288 ops/sec [1,112..1,391] → 1,243 ops/sec [1,141..1,514] ~ overlap (-3.5%) 3,095 ops/sec [3,039..3,265] → 3,112 ops/sec [3,085..3,256] ~ overlap (+0.5%)
for-of.js — Interp: 🟢 5, 2 unch. · avg +3.1% · Bytecode: 7 unch. · avg -0.7%
Benchmark Interpreted Δ Bytecode Δ
for...of with 10-element array 12,989 ops/sec [12,897..13,033] → 13,766 ops/sec [13,689..14,457] 🟢 +6.0% 76,316 ops/sec [73,248..80,241] → 82,078 ops/sec [67,984..84,827] ~ overlap (+7.5%)
for...of with 100-element array 1,548 ops/sec [1,530..1,557] → 1,625 ops/sec [1,585..1,654] 🟢 +5.0% 10,758 ops/sec [10,132..11,416] → 10,568 ops/sec [9,985..11,455] ~ overlap (-1.8%)
for...of with string (10 chars) 10,307 ops/sec [10,089..10,400] → 10,741 ops/sec [10,570..12,773] 🟢 +4.2% 28,211 ops/sec [26,882..30,893] → 26,905 ops/sec [26,452..27,366] ~ overlap (-4.6%)
for...of with Set (10 elements) 13,467 ops/sec [12,918..13,625] → 13,753 ops/sec [13,256..19,781] ~ overlap (+2.1%) 82,512 ops/sec [80,679..89,614] → 83,447 ops/sec [80,453..96,589] ~ overlap (+1.1%)
for...of with Map entries (10 entries) 7,021 ops/sec [6,921..7,021] → 7,300 ops/sec [7,047..7,380] 🟢 +4.0% 12,330 ops/sec [12,271..12,340] → 12,040 ops/sec [11,903..12,760] ~ overlap (-2.4%)
for...of with destructuring 7,960 ops/sec [7,877..8,083] → 8,125 ops/sec [8,118..8,157] 🟢 +2.1% 14,803 ops/sec [14,589..16,303] → 14,771 ops/sec [14,517..21,086] ~ overlap (-0.2%)
for-await-of with sync array 8,624 ops/sec [8,578..10,277] → 8,503 ops/sec [8,458..8,656] ~ overlap (-1.4%) 1,807 ops/sec [1,764..2,035] → 1,730 ops/sec [1,722..1,889] ~ overlap (-4.3%)
generators.js — Interp: 🟢 1, 🔴 1, 2 unch. · avg +7.2% · Bytecode: 4 unch. · avg -0.8%
Benchmark Interpreted Δ Bytecode Δ
manual next over object generator 598 ops/sec [596..599] → 585 ops/sec [582..588] 🔴 -2.2% 954 ops/sec [948..1,011] → 951 ops/sec [933..1,173] ~ overlap (-0.2%)
for...of over object generator 1,008 ops/sec [976..1,107] → 1,048 ops/sec [1,025..1,256] ~ overlap (+4.0%) 1,413 ops/sec [1,400..1,415] → 1,404 ops/sec [1,381..1,496] ~ overlap (-0.6%)
yield delegation 981 ops/sec [970..986] → 1,132 ops/sec [976..1,421] ~ overlap (+15.4%) 1,440 ops/sec [1,372..1,451] → 1,412 ops/sec [1,405..1,419] ~ overlap (-1.9%)
class generator method 1,007 ops/sec [953..1,087] → 1,123 ops/sec [1,119..1,131] 🟢 +11.5% 1,429 ops/sec [1,289..1,504] → 1,423 ops/sec [1,386..1,483] ~ overlap (-0.4%)
intl.js — Interp: 🆕 6 · Bytecode: 🆕 6
Benchmark Interpreted Δ Bytecode Δ
format decimal 25,378 ops/sec [25,342..25,555] 🆕 25,498 ops/sec [24,271..29,433] 🆕
format currency 20,384 ops/sec [19,779..22,689] 🆕 22,459 ops/sec [19,631..23,406] 🆕
format UTC date 2,319 ops/sec [2,310..2,429] 🆕 2,136 ops/sec [2,096..2,147] 🆕
formatRange UTC dates 2,548 ops/sec [2,529..2,559] 🆕 2,357 ops/sec [2,349..2,379] 🆕
compare numeric strings 88,961 ops/sec [86,770..102,373] 🆕 101,022 ops/sec [100,685..104,270] 🆕
sort short string list 18,598 ops/sec [18,272..18,661] 🆕 19,769 ops/sec [19,739..19,800] 🆕
iterators.js — Interp: 🟢 1, 🔴 11, 30 unch. · avg -2.4% · Bytecode: 🔴 6, 36 unch. · avg -1.6%
Benchmark Interpreted Δ Bytecode Δ
Iterator.from({next}).toArray() — 20 elements 2,931 ops/sec [2,733..2,938] → 2,752 ops/sec [2,727..2,755] ~ overlap (-6.1%) 3,897 ops/sec [3,826..4,476] → 3,578 ops/sec [3,402..3,872] ~ overlap (-8.2%)
Iterator.from({next}).toArray() — 50 elements 1,154 ops/sec [1,152..1,201] → 1,156 ops/sec [1,151..1,176] ~ overlap (+0.2%) 1,648 ops/sec [1,643..1,666] → 1,638 ops/sec [1,513..1,715] ~ overlap (-0.6%)
spread pre-wrapped iterator — 20 elements 3,220 ops/sec [2,864..3,580] → 2,943 ops/sec [2,861..3,350] ~ overlap (-8.6%) 5,310 ops/sec [5,246..5,338] → 5,329 ops/sec [5,261..5,351] ~ overlap (+0.4%)
Iterator.from({next}).forEach — 50 elements 877 ops/sec [867..1,030] → 846 ops/sec [831..852] 🔴 -3.5% 1,230 ops/sec [1,206..1,240] → 1,248 ops/sec [1,236..1,373] ~ overlap (+1.5%)
Iterator.from({next}).reduce — 50 elements 881 ops/sec [865..1,002] → 891 ops/sec [888..988] ~ overlap (+1.1%) 1,254 ops/sec [1,228..1,308] → 1,248 ops/sec [1,234..1,276] ~ overlap (-0.5%)
wrap array iterator 18,811 ops/sec [17,325..22,889] → 16,882 ops/sec [16,671..17,741] ~ overlap (-10.3%) 17,654 ops/sec [17,433..19,954] → 18,512 ops/sec [17,282..21,145] ~ overlap (+4.9%)
wrap plain {next()} object 1,967 ops/sec [1,961..2,144] → 1,882 ops/sec [1,858..1,898] 🔴 -4.3% 2,724 ops/sec [2,649..3,026] → 2,698 ops/sec [2,663..2,725] ~ overlap (-1.0%)
map + toArray (50 elements) 669 ops/sec [637..741] → 653 ops/sec [644..663] ~ overlap (-2.5%) 905 ops/sec [898..912] → 887 ops/sec [880..920] ~ overlap (-2.0%)
filter + toArray (50 elements) 699 ops/sec [695..704] → 695 ops/sec [688..711] ~ overlap (-0.5%) 974 ops/sec [964..977] → 938 ops/sec [912..964] 🔴 -3.7%
take(10) + toArray (50 element source) 3,883 ops/sec [3,829..3,906] → 3,853 ops/sec [3,834..3,870] ~ overlap (-0.8%) 4,993 ops/sec [4,965..5,542] → 4,797 ops/sec [4,780..4,977] ~ overlap (-3.9%)
drop(40) + toArray (50 element source) 1,014 ops/sec [985..1,058] → 976 ops/sec [972..1,105] ~ overlap (-3.8%) 1,334 ops/sec [1,327..1,393] → 1,315 ops/sec [1,255..1,450] ~ overlap (-1.5%)
chained map + filter + take (100 element source) 1,085 ops/sec [1,076..1,089] → 1,087 ops/sec [1,067..1,167] ~ overlap (+0.1%) 1,416 ops/sec [1,409..1,419] → 1,388 ops/sec [1,342..1,448] ~ overlap (-2.0%)
some + every (50 elements) 472 ops/sec [461..534] → 474 ops/sec [465..533] ~ overlap (+0.5%) 708 ops/sec [695..714] → 716 ops/sec [709..815] ~ overlap (+1.1%)
find (50 elements) 1,061 ops/sec [1,042..1,072] → 1,060 ops/sec [962..1,147] ~ overlap (-0.1%) 1,528 ops/sec [1,490..1,540] → 1,518 ops/sec [1,487..1,545] ~ overlap (-0.6%)
concat 2 arrays (10 + 10 elements) 6,743 ops/sec [6,561..7,123] → 6,479 ops/sec [6,406..7,542] ~ overlap (-3.9%) 6,588 ops/sec [6,411..8,248] → 6,406 ops/sec [6,259..7,529] ~ overlap (-2.8%)
concat 5 arrays (10 elements each) 2,921 ops/sec [2,826..3,239] → 2,790 ops/sec [2,765..3,435] ~ overlap (-4.5%) 2,769 ops/sec [2,668..2,825] → 2,684 ops/sec [2,658..2,694] ~ overlap (-3.1%)
concat 2 arrays (20 + 20 elements) 3,702 ops/sec [3,571..4,069] → 3,566 ops/sec [3,139..3,878] ~ overlap (-3.7%) 3,600 ops/sec [3,485..3,741] → 3,449 ops/sec [3,338..3,475] 🔴 -4.2%
concat + filter + toArray (20 + 20 elements) 1,367 ops/sec [1,348..1,407] → 1,412 ops/sec [1,324..1,755] ~ overlap (+3.3%) 1,594 ops/sec [1,533..1,599] → 1,535 ops/sec [1,490..1,561] ~ overlap (-3.7%)
concat + map + take (20 + 20 elements, take 10) 3,512 ops/sec [3,465..3,548] → 3,780 ops/sec [3,323..4,480] ~ overlap (+7.6%) 3,830 ops/sec [3,778..3,856] → 3,552 ops/sec [3,534..3,572] 🔴 -7.3%
concat Sets (15 + 15 elements) 4,885 ops/sec [4,783..5,638] → 4,728 ops/sec [4,665..4,756] 🔴 -3.2% 4,677 ops/sec [4,534..6,953] → 4,618 ops/sec [4,551..4,719] ~ overlap (-1.3%)
concat strings (13 + 13 characters) 5,364 ops/sec [5,183..6,937] → 5,027 ops/sec [4,981..5,034] 🔴 -6.3% 5,165 ops/sec [4,958..6,450] → 5,036 ops/sec [4,954..5,122] ~ overlap (-2.5%)
zip 2 arrays (10 + 10 elements) 12,244 ops/sec [12,129..12,283] → 11,353 ops/sec [10,923..11,583] 🔴 -7.3% 11,659 ops/sec [11,536..13,979] → 11,986 ops/sec [11,594..14,690] ~ overlap (+2.8%)
zip 3 arrays (10 elements each) 11,518 ops/sec [11,165..12,555] → 10,726 ops/sec [10,643..10,780] 🔴 -6.9% 11,105 ops/sec [10,920..11,250] → 10,516 ops/sec [10,193..11,208] ~ overlap (-5.3%)
zip 2 arrays (20 + 20 elements) 7,354 ops/sec [7,218..8,277] → 7,676 ops/sec [6,837..7,907] ~ overlap (+4.4%) 7,061 ops/sec [6,825..7,112] → 7,517 ops/sec [6,835..7,793] ~ overlap (+6.5%)
zip 2 arrays (50 + 50 elements) 3,348 ops/sec [3,295..3,389] → 3,207 ops/sec [3,100..3,854] ~ overlap (-4.2%) 3,075 ops/sec [3,024..3,164] → 3,195 ops/sec [3,146..3,753] ~ overlap (+3.9%)
zip shortest mode (20 + 10 elements) 12,008 ops/sec [11,796..14,179] → 11,498 ops/sec [11,441..11,547] 🔴 -4.3% 11,507 ops/sec [11,214..12,304] → 11,704 ops/sec [11,323..16,403] ~ overlap (+1.7%)
zip longest mode (10 + 20 elements) 6,883 ops/sec [6,858..6,900] → 7,574 ops/sec [7,083..7,900] 🟢 +10.0% 6,673 ops/sec [6,487..8,465] → 6,579 ops/sec [6,159..7,419] ~ overlap (-1.4%)
zip strict mode (20 + 20 elements) 7,092 ops/sec [7,035..7,114] → 6,797 ops/sec [6,753..6,826] 🔴 -4.2% 7,037 ops/sec [6,772..8,277] → 6,775 ops/sec [6,525..8,181] ~ overlap (-3.7%)
zip + map + toArray (20 + 20 elements) 2,026 ops/sec [1,991..2,271] → 2,054 ops/sec [2,018..3,193] ~ overlap (+1.4%) 2,132 ops/sec [2,127..2,140] → 2,087 ops/sec [2,044..2,138] ~ overlap (-2.1%)
zip + filter + toArray (20 + 20 elements) 2,151 ops/sec [2,114..2,637] → 2,238 ops/sec [2,096..2,439] ~ overlap (+4.1%) 2,334 ops/sec [2,252..2,530] → 2,239 ops/sec [2,149..2,818] ~ overlap (-4.1%)
zip Sets (15 + 15 elements) 9,327 ops/sec [9,206..9,993] → 8,938 ops/sec [8,776..9,108] 🔴 -4.2% 9,381 ops/sec [9,090..11,328] → 9,076 ops/sec [8,965..10,374] ~ overlap (-3.3%)
zipKeyed 2 keys (10 elements each) 12,135 ops/sec [11,278..12,870] → 14,272 ops/sec [11,238..19,112] ~ overlap (+17.6%) 11,395 ops/sec [11,318..14,086] → 11,402 ops/sec [11,114..11,537] ~ overlap (+0.1%)
zipKeyed 3 keys (20 elements each) 6,069 ops/sec [6,045..7,298] → 5,901 ops/sec [5,816..6,952] ~ overlap (-2.8%) 5,879 ops/sec [5,565..6,257] → 5,875 ops/sec [5,791..5,954] ~ overlap (-0.1%)
zipKeyed longest mode (10 + 20 elements) 6,596 ops/sec [6,439..10,024] → 6,488 ops/sec [6,318..6,701] ~ overlap (-1.6%) 6,517 ops/sec [6,115..9,239] → 6,331 ops/sec [6,258..6,876] ~ overlap (-2.9%)
zipKeyed strict mode (20 + 20 elements) 7,109 ops/sec [6,565..10,238] → 6,532 ops/sec [6,475..6,564] 🔴 -8.1% 6,495 ops/sec [6,308..6,982] → 6,622 ops/sec [6,539..6,674] ~ overlap (+1.9%)
zipKeyed + filter + map (20 elements) 1,847 ops/sec [1,846..1,868] → 1,830 ops/sec [1,818..1,890] ~ overlap (-0.9%) 2,256 ops/sec [2,231..2,279] → 2,233 ops/sec [2,205..2,411] ~ overlap (-1.0%)
array.values().map().filter().toArray() 762 ops/sec [720..768] → 698 ops/sec [685..812] ~ overlap (-8.4%) 871 ops/sec [854..876] → 847 ops/sec [836..850] 🔴 -2.7%
array.values().take(5).toArray() 15,122 ops/sec [14,417..16,121] → 13,765 ops/sec [13,670..13,844] 🔴 -9.0% 14,959 ops/sec [14,794..15,056] → 14,835 ops/sec [14,655..15,013] ~ overlap (-0.8%)
array.values().drop(45).toArray() 3,645 ops/sec [3,045..3,747] → 2,981 ops/sec [2,868..3,193] ~ overlap (-18.2%) 2,921 ops/sec [2,912..2,935] → 2,821 ops/sec [2,776..3,214] ~ overlap (-3.4%)
map.entries() chained helpers 1,033 ops/sec [1,010..1,175] → 1,035 ops/sec [1,024..1,142] ~ overlap (+0.2%) 1,093 ops/sec [1,085..1,098] → 1,055 ops/sec [1,044..1,066] 🔴 -3.4%
set.values() chained helpers 1,836 ops/sec [1,770..1,979] → 1,792 ops/sec [1,702..1,911] ~ overlap (-2.4%) 2,164 ops/sec [2,089..2,434] → 2,041 ops/sec [2,025..2,054] 🔴 -5.7%
string iterator map + toArray 1,965 ops/sec [1,959..2,054] → 1,817 ops/sec [1,778..2,080] ~ overlap (-7.5%) 2,088 ops/sec [2,050..2,093] → 2,012 ops/sec [1,957..2,125] ~ overlap (-3.6%)
json.js — Interp: 🟢 6, 14 unch. · avg +4.4% · Bytecode: 🔴 3, 17 unch. · avg -1.8%
Benchmark Interpreted Δ Bytecode Δ
parse simple object 59,084 ops/sec [58,686..59,208] → 59,129 ops/sec [58,514..60,036] ~ overlap (+0.1%) 66,333 ops/sec [66,042..66,527] → 65,423 ops/sec [64,925..70,010] ~ overlap (-1.4%)
parse nested object 40,858 ops/sec [40,721..41,089] → 41,228 ops/sec [40,874..47,134] ~ overlap (+0.9%) 43,210 ops/sec [41,079..43,924] → 44,179 ops/sec [43,001..48,800] ~ overlap (+2.2%)
parse array of objects 25,788 ops/sec [25,043..26,171] → 28,011 ops/sec [27,044..32,052] 🟢 +8.6% 27,689 ops/sec [25,984..28,813] → 25,880 ops/sec [25,502..27,758] ~ overlap (-6.5%)
parse large flat object 27,359 ops/sec [26,493..27,539] → 29,060 ops/sec [28,988..29,310] 🟢 +6.2% 30,071 ops/sec [27,959..31,597] → 27,819 ops/sec [27,770..31,493] ~ overlap (-7.5%)
parse mixed types 30,931 ops/sec [30,656..32,140] → 33,964 ops/sec [32,460..38,216] 🟢 +9.8% 33,096 ops/sec [32,388..36,101] → 32,516 ops/sec [32,216..33,535] ~ overlap (-1.8%)
stringify simple object 58,519 ops/sec [56,341..78,525] → 58,677 ops/sec [58,173..61,327] ~ overlap (+0.3%) 57,278 ops/sec [55,173..65,584] → 56,806 ops/sec [55,093..59,289] ~ overlap (-0.8%)
stringify nested object 34,317 ops/sec [26,572..41,815] → 35,021 ops/sec [34,918..35,087] ~ overlap (+2.1%) 31,042 ops/sec [30,983..35,989] → 30,173 ops/sec [29,389..32,500] ~ overlap (-2.8%)
stringify array of objects 15,190 ops/sec [14,880..15,927] → 15,914 ops/sec [15,461..17,465] ~ overlap (+4.8%) 16,272 ops/sec [16,216..16,296] → 15,822 ops/sec [15,400..19,271] ~ overlap (-2.8%)
stringify mixed types 23,033 ops/sec [22,907..23,254] → 25,643 ops/sec [24,407..29,013] 🟢 +11.3% 22,111 ops/sec [21,993..24,390] → 21,052 ops/sec [20,423..26,031] ~ overlap (-4.8%)
reviver doubles numbers 9,479 ops/sec [9,441..9,518] → 9,905 ops/sec [9,728..10,029] 🟢 +4.5% 14,263 ops/sec [14,190..14,432] → 13,544 ops/sec [13,456..14,019] 🔴 -5.0%
reviver filters properties 9,704 ops/sec [9,155..10,084] → 9,812 ops/sec [9,611..9,846] ~ overlap (+1.1%) 12,163 ops/sec [11,987..13,816] → 13,187 ops/sec [12,158..14,193] ~ overlap (+8.4%)
reviver on nested object 11,180 ops/sec [11,087..11,378] → 11,590 ops/sec [11,279..12,836] ~ overlap (+3.7%) 15,120 ops/sec [15,068..15,169] → 15,105 ops/sec [14,930..17,850] ~ overlap (-0.1%)
reviver on array 5,943 ops/sec [5,915..5,949] → 6,042 ops/sec [5,934..6,152] ~ overlap (+1.7%) 9,153 ops/sec [8,609..9,976] → 8,753 ops/sec [8,591..10,019] ~ overlap (-4.4%)
replacer function doubles numbers 11,744 ops/sec [9,817..13,945] → 10,703 ops/sec [10,306..10,815] ~ overlap (-8.9%) 14,983 ops/sec [14,873..15,085] → 14,736 ops/sec [14,061..14,802] 🔴 -1.6%
replacer function excludes properties 13,274 ops/sec [12,526..15,410] → 14,930 ops/sec [13,885..17,694] ~ overlap (+12.5%) 18,310 ops/sec [18,002..18,434] → 18,295 ops/sec [17,547..18,922] ~ overlap (-0.1%)
array replacer (allowlist) 38,332 ops/sec [37,686..44,370] → 39,984 ops/sec [39,692..48,094] ~ overlap (+4.3%) 34,137 ops/sec [33,852..34,337] → 34,232 ops/sec [34,171..34,345] ~ overlap (+0.3%)
stringify with 2-space indent 30,998 ops/sec [29,217..35,080] → 32,870 ops/sec [32,743..46,812] ~ overlap (+6.0%) 29,279 ops/sec [29,154..29,808] → 30,048 ops/sec [27,405..33,006] ~ overlap (+2.6%)
stringify with tab indent 30,550 ops/sec [29,930..31,667] → 32,410 ops/sec [32,179..33,041] 🟢 +6.1% 29,837 ops/sec [29,480..30,247] → 27,464 ops/sec [27,299..28,710] 🔴 -8.0%
parse then stringify 19,186 ops/sec [19,047..23,426] → 20,937 ops/sec [19,917..20,966] ~ overlap (+9.1%) 21,152 ops/sec [20,558..21,673] → 20,599 ops/sec [19,220..22,463] ~ overlap (-2.6%)
stringify then parse 11,647 ops/sec [11,459..12,914] → 12,149 ops/sec [11,972..15,406] ~ overlap (+4.3%) 12,554 ops/sec [12,535..12,585] → 12,604 ops/sec [11,849..13,908] ~ overlap (+0.4%)
jsx.jsx — Interp: 🟢 8, 13 unch. · avg +6.2% · Bytecode: 🟢 3, 🔴 1, 17 unch. · avg -1.0%
Benchmark Interpreted Δ Bytecode Δ
simple element 60,003 ops/sec [58,892..62,950] → 64,407 ops/sec [63,907..64,857] 🟢 +7.3% 82,864 ops/sec [78,962..83,872] → 83,162 ops/sec [78,946..102,553] ~ overlap (+0.4%)
self-closing element 63,054 ops/sec [60,980..64,606] → 66,625 ops/sec [65,642..78,706] 🟢 +5.7% 89,586 ops/sec [86,760..103,717] → 87,452 ops/sec [86,276..103,998] ~ overlap (-2.4%)
element with string attribute 59,229 ops/sec [52,851..61,626] → 57,722 ops/sec [57,025..70,147] ~ overlap (-2.5%) 69,399 ops/sec [68,020..74,414] → 67,317 ops/sec [65,022..72,740] ~ overlap (-3.0%)
element with multiple attributes 49,159 ops/sec [47,712..49,371] → 49,439 ops/sec [48,776..72,565] ~ overlap (+0.6%) 50,686 ops/sec [49,980..54,579] → 49,027 ops/sec [46,022..67,873] ~ overlap (-3.3%)
element with expression attribute 49,700 ops/sec [49,083..51,902] → 50,994 ops/sec [50,553..54,938] ~ overlap (+2.6%) 69,556 ops/sec [69,103..86,815] → 68,302 ops/sec [67,449..80,837] ~ overlap (-1.8%)
text child 63,401 ops/sec [62,720..63,822] → 64,937 ops/sec [60,665..65,463] ~ overlap (+2.4%) 85,578 ops/sec [84,755..86,377] → 82,971 ops/sec [80,574..90,730] ~ overlap (-3.0%)
expression child 60,347 ops/sec [59,469..61,158] → 59,315 ops/sec [58,303..59,655] ~ overlap (-1.7%) 80,884 ops/sec [80,073..81,077] → 77,669 ops/sec [76,016..113,202] ~ overlap (-4.0%)
mixed text and expression 59,575 ops/sec [57,079..64,197] → 58,147 ops/sec [57,485..61,220] ~ overlap (-2.4%) 75,937 ops/sec [74,210..81,478] → 73,399 ops/sec [71,258..99,860] ~ overlap (-3.3%)
nested elements (3 levels) 23,398 ops/sec [19,981..27,883] → 27,671 ops/sec [24,899..29,107] ~ overlap (+18.3%) 32,226 ops/sec [32,088..33,731] → 32,464 ops/sec [27,095..44,910] ~ overlap (+0.7%)
sibling children 17,670 ops/sec [17,273..18,605] → 20,941 ops/sec [18,854..25,525] 🟢 +18.5% 23,951 ops/sec [23,154..31,863] → 23,869 ops/sec [23,629..33,412] ~ overlap (-0.3%)
component element 45,680 ops/sec [45,103..46,214] → 49,714 ops/sec [49,487..63,141] 🟢 +8.8% 62,710 ops/sec [62,169..77,453] → 61,949 ops/sec [60,712..62,553] ~ overlap (-1.2%)
component with children 32,290 ops/sec [28,630..36,010] → 32,294 ops/sec [30,620..33,715] ~ overlap (+0.0%) 38,624 ops/sec [38,273..44,125] → 39,045 ops/sec [35,619..47,394] ~ overlap (+1.1%)
dotted component 43,562 ops/sec [40,782..49,554] → 52,856 ops/sec [46,592..56,940] ~ overlap (+21.3%) 58,408 ops/sec [56,205..60,244] → 46,413 ops/sec [46,284..46,535] 🔴 -20.5%
empty fragment 63,753 ops/sec [60,769..68,355] → 66,785 ops/sec [62,489..77,969] ~ overlap (+4.8%) 93,134 ops/sec [86,640..132,847] → 87,109 ops/sec [86,719..87,645] ~ overlap (-6.5%)
fragment with children 17,481 ops/sec [17,159..19,813] → 18,796 ops/sec [18,646..18,813] ~ overlap (+7.5%) 24,779 ops/sec [24,188..27,353] → 23,992 ops/sec [23,170..24,662] ~ overlap (-3.2%)
spread attributes 35,154 ops/sec [32,991..36,119] → 36,498 ops/sec [34,436..40,639] ~ overlap (+3.8%) 36,108 ops/sec [35,981..36,418] → 37,529 ops/sec [37,092..40,507] 🟢 +3.9%
spread with overrides 30,165 ops/sec [29,875..30,453] → 33,528 ops/sec [32,342..36,997] 🟢 +11.2% 31,422 ops/sec [31,251..31,525] → 32,987 ops/sec [32,274..33,385] 🟢 +5.0%
shorthand props 50,062 ops/sec [47,276..56,097] → 49,873 ops/sec [48,349..50,696] ~ overlap (-0.4%) 54,403 ops/sec [54,026..54,535] → 56,139 ops/sec [54,986..64,750] 🟢 +3.2%
nav bar structure 8,896 ops/sec [8,733..8,955] → 10,066 ops/sec [9,179..10,409] 🟢 +13.2% 11,164 ops/sec [10,816..11,301] → 11,978 ops/sec [11,279..14,727] ~ overlap (+7.3%)
card component tree 10,353 ops/sec [10,102..10,747] → 11,021 ops/sec [10,877..12,512] 🟢 +6.5% 12,094 ops/sec [11,641..14,448] → 12,734 ops/sec [12,411..12,785] ~ overlap (+5.3%)
10 list items via Array.from 4,367 ops/sec [4,336..4,424] → 4,614 ops/sec [4,472..5,485] 🟢 +5.6% 4,966 ops/sec [4,881..6,332] → 5,162 ops/sec [5,006..5,235] ~ overlap (+3.9%)
modules.js — Interp: 🟢 1, 8 unch. · avg +0.5% · Bytecode: 🔴 1, 8 unch. · avg -0.7%
Benchmark Interpreted Δ Bytecode Δ
call imported function 93,838 ops/sec [92,849..98,042] → 100,812 ops/sec [98,323..103,387] 🟢 +7.4% 47,989 ops/sec [44,748..53,639] → 46,918 ops/sec [45,900..47,925] ~ overlap (-2.2%)
call two imported functions 54,203 ops/sec [52,815..58,659] → 56,249 ops/sec [55,170..58,236] ~ overlap (+3.8%) 26,263 ops/sec [24,530..29,467] → 24,424 ops/sec [24,191..24,773] ~ overlap (-7.0%)
read imported constant 310,720 ops/sec [305,361..315,547] → 303,438 ops/sec [296,069..352,195] ~ overlap (-2.3%) 53,639 ops/sec [51,022..60,191] → 50,535 ops/sec [48,665..50,982] 🔴 -5.8%
read imported string 304,191 ops/sec [295,197..392,567] → 311,727 ops/sec [302,092..322,723] ~ overlap (+2.5%) 49,945 ops/sec [48,520..51,093] → 50,436 ops/sec [49,576..51,256] ~ overlap (+1.0%)
read JSON string property 334,663 ops/sec [306,333..408,914] → 330,236 ops/sec [311,035..340,463] ~ overlap (-1.3%) 51,488 ops/sec [50,486..56,652] → 51,389 ops/sec [50,621..51,773] ~ overlap (-0.2%)
read JSON number property 314,495 ops/sec [312,413..405,372] → 311,592 ops/sec [306,996..317,570] ~ overlap (-0.9%) 49,478 ops/sec [48,613..51,025] → 50,114 ops/sec [48,065..58,142] ~ overlap (+1.3%)
read JSON boolean property 318,417 ops/sec [307,965..389,942] → 316,050 ops/sec [298,521..376,763] ~ overlap (-0.7%) 51,615 ops/sec [49,784..54,396] → 50,716 ops/sec [50,106..58,890] ~ overlap (-1.7%)
read JSON array property 318,223 ops/sec [298,980..319,442] → 312,578 ops/sec [302,155..387,860] ~ overlap (-1.8%) 51,222 ops/sec [50,862..51,471] → 51,062 ops/sec [49,546..57,708] ~ overlap (-0.3%)
read multiple JSON properties 187,017 ops/sec [179,967..212,360] → 183,435 ops/sec [176,662..237,320] ~ overlap (-1.9%) 18,078 ops/sec [17,702..19,952] → 19,608 ops/sec [17,830..21,970] ~ overlap (+8.5%)
numbers.js — Interp: 🟢 3, 8 unch. · avg +3.6% · Bytecode: 🟢 1, 10 unch. · avg +5.9%
Benchmark Interpreted Δ Bytecode Δ
integer arithmetic 93,570 ops/sec [90,201..111,021] → 97,489 ops/sec [92,268..126,999] ~ overlap (+4.2%) 354,962 ops/sec [336,609..403,752] → 403,591 ops/sec [364,472..471,886] ~ overlap (+13.7%)
floating point arithmetic 107,530 ops/sec [106,491..135,596] → 109,737 ops/sec [104,396..115,862] ~ overlap (+2.1%) 211,353 ops/sec [207,177..284,613] → 211,466 ops/sec [208,369..213,363] ~ overlap (+0.1%)
number coercion 42,285 ops/sec [41,991..42,528] → 43,615 ops/sec [43,219..55,059] 🟢 +3.1% 61,570 ops/sec [60,150..65,322] → 62,856 ops/sec [60,036..67,016] ~ overlap (+2.1%)
toFixed 33,413 ops/sec [33,207..33,521] → 38,910 ops/sec [34,666..44,108] 🟢 +16.5% 37,202 ops/sec [36,985..37,290] → 40,333 ops/sec [37,150..49,142] ~ overlap (+8.4%)
toString 48,745 ops/sec [48,143..50,086] → 51,370 ops/sec [50,804..51,401] 🟢 +5.4% 63,185 ops/sec [60,896..71,686] → 64,963 ops/sec [62,307..78,092] ~ overlap (+2.8%)
valueOf 71,040 ops/sec [68,757..82,624] → 71,867 ops/sec [70,679..73,557] ~ overlap (+1.2%) 90,904 ops/sec [89,045..122,712] → 106,387 ops/sec [89,680..108,424] ~ overlap (+17.0%)
toPrecision 23,577 ops/sec [22,774..26,097] → 23,755 ops/sec [23,196..24,075] ~ overlap (+0.8%) 24,723 ops/sec [24,077..25,902] → 25,255 ops/sec [24,084..25,366] ~ overlap (+2.2%)
Number.isNaN 77,570 ops/sec [74,760..78,605] → 78,153 ops/sec [76,059..81,535] ~ overlap (+0.8%) 97,618 ops/sec [96,463..102,679] → 101,708 ops/sec [100,778..114,766] ~ overlap (+4.2%)
Number.isFinite 75,326 ops/sec [73,454..92,238] → 79,173 ops/sec [74,176..81,157] ~ overlap (+5.1%) 90,431 ops/sec [89,219..92,013] → 93,286 ops/sec [92,641..93,529] 🟢 +3.2%
Number.isInteger 79,376 ops/sec [79,249..79,441] → 78,657 ops/sec [75,878..97,439] ~ overlap (-0.9%) 92,367 ops/sec [91,601..97,882] → 98,171 ops/sec [96,777..98,467] ~ overlap (+6.3%)
Number.parseInt and parseFloat 65,544 ops/sec [65,288..66,067] → 66,344 ops/sec [65,036..66,994] ~ overlap (+1.2%) 70,550 ops/sec [70,039..75,234] → 74,068 ops/sec [73,805..75,161] ~ overlap (+5.0%)
objects.js — Interp: 🟢 1, 6 unch. · avg +0.5% · Bytecode: 7 unch. · avg +5.8%
Benchmark Interpreted Δ Bytecode Δ
create simple object 152,536 ops/sec [138,033..179,065] → 148,614 ops/sec [145,006..151,165] ~ overlap (-2.6%) 126,466 ops/sec [124,603..155,439] → 140,011 ops/sec [127,844..182,539] ~ overlap (+10.7%)
create nested object 94,278 ops/sec [77,675..106,671] → 84,167 ops/sec [83,013..141,632] ~ overlap (-10.7%) 59,513 ops/sec [58,026..67,856] → 67,559 ops/sec [59,859..69,001] ~ overlap (+13.5%)
create 50 objects via Array.from 2,397 ops/sec [2,370..2,407] → 2,599 ops/sec [2,537..3,081] 🟢 +8.4% 2,430 ops/sec [2,388..3,184] → 2,505 ops/sec [2,398..2,630] ~ overlap (+3.1%)
property read 130,276 ops/sec [120,635..136,372] → 124,689 ops/sec [123,443..133,788] ~ overlap (-4.3%) 294,885 ops/sec [252,003..296,017] → 256,385 ops/sec [248,724..263,357] ~ overlap (-13.1%)
Object.keys 77,175 ops/sec [76,989..84,296] → 79,641 ops/sec [78,303..80,736] ~ overlap (+3.2%) 94,724 ops/sec [93,734..101,284] → 96,666 ops/sec [94,514..114,140] ~ overlap (+2.1%)
Object.entries 40,518 ops/sec [38,860..47,658] → 42,604 ops/sec [40,972..48,984] ~ overlap (+5.1%) 46,710 ops/sec [44,262..58,369] → 53,333 ops/sec [43,962..53,752] ~ overlap (+14.2%)
spread operator 51,344 ops/sec [50,238..68,922] → 53,634 ops/sec [53,360..65,496] ~ overlap (+4.5%) 52,427 ops/sec [51,259..69,437] → 57,710 ops/sec [52,444..58,635] ~ overlap (+10.1%)
promises.js — Interp: 🟢 1, 11 unch. · avg +3.8% · Bytecode: 🔴 2, 10 unch. · avg -3.3%
Benchmark Interpreted Δ Bytecode Δ
Promise.resolve(value) 69,464 ops/sec [67,938..83,463] → 81,141 ops/sec [66,938..120,128] ~ overlap (+16.8%) 75,693 ops/sec [75,435..76,859] → 73,520 ops/sec [71,678..88,972] ~ overlap (-2.9%)
new Promise(resolve => resolve(value)) 45,235 ops/sec [43,158..45,265] → 45,884 ops/sec [44,561..46,120] ~ overlap (+1.4%) 58,905 ops/sec [55,772..61,717] → 54,635 ops/sec [53,575..55,216] 🔴 -7.2%
Promise.reject(reason) 69,198 ops/sec [67,316..71,822] → 69,220 ops/sec [67,873..69,375] ~ overlap (+0.0%) 77,874 ops/sec [72,840..89,959] → 73,268 ops/sec [71,658..74,412] ~ overlap (-5.9%)
resolve + then (1 handler) 22,277 ops/sec [21,578..25,706] → 23,243 ops/sec [23,070..28,463] ~ overlap (+4.3%) 27,512 ops/sec [24,775..34,041] → 25,195 ops/sec [24,091..35,340] ~ overlap (-8.4%)
resolve + then chain (3 deep) 9,259 ops/sec [8,893..9,490] → 9,668 ops/sec [9,537..10,938] 🟢 +4.4% 10,434 ops/sec [10,318..11,567] → 11,247 ops/sec [10,077..13,625] ~ overlap (+7.8%)
resolve + then chain (10 deep) 3,354 ops/sec [3,046..3,529] → 3,237 ops/sec [3,161..4,198] ~ overlap (-3.5%) 3,406 ops/sec [3,365..4,147] → 3,370 ops/sec [2,376..4,571] ~ overlap (-1.1%)
reject + catch + then 13,855 ops/sec [12,735..15,971] → 13,972 ops/sec [13,766..20,837] ~ overlap (+0.8%) 15,703 ops/sec [14,295..17,234] → 14,305 ops/sec [13,619..14,940] ~ overlap (-8.9%)
resolve + finally + then 6,634 ops/sec [6,406..7,792] → 6,909 ops/sec [6,789..6,931] ~ overlap (+4.1%) 6,587 ops/sec [6,449..7,168] → 6,661 ops/sec [6,620..6,718] ~ overlap (+1.1%)
Promise.all (5 resolved) 4,486 ops/sec [4,386..4,632] → 4,674 ops/sec [4,625..4,749] ~ overlap (+4.2%) 4,748 ops/sec [4,585..4,919] → 4,589 ops/sec [4,564..4,786] ~ overlap (-3.3%)
Promise.race (5 resolved) 5,222 ops/sec [5,089..7,076] → 5,436 ops/sec [5,343..6,698] ~ overlap (+4.1%) 5,205 ops/sec [5,178..5,339] → 5,193 ops/sec [5,028..5,588] ~ overlap (-0.2%)
Promise.allSettled (5 mixed) 3,822 ops/sec [3,717..4,033] → 4,086 ops/sec [3,977..4,096] ~ overlap (+6.9%) 3,983 ops/sec [3,739..5,264] → 3,706 ops/sec [3,695..3,734] 🔴 -6.9%
Promise.any (5 mixed) 4,758 ops/sec [4,747..4,790] → 4,850 ops/sec [4,668..8,260] ~ overlap (+1.9%) 4,711 ops/sec [4,420..4,979] → 4,534 ops/sec [4,442..5,629] ~ overlap (-3.8%)
property-access.js — Interp: 🟢 1, 4 unch. · avg +12.2% · Bytecode: 5 unch. · avg -1.6%
Benchmark Interpreted Δ Bytecode Δ
class instance fields across 1000 instances 140 ops/sec [135..144] → 150 ops/sec [149..155] 🟢 +7.0% 678 ops/sec [655..1,090] → 648 ops/sec [637..657] ~ overlap (-4.4%)
object literal fields across 1000 literals 157 ops/sec [140..169] → 188 ops/sec [153..200] ~ overlap (+19.4%) 662 ops/sec [649..695] → 645 ops/sec [633..712] ~ overlap (-2.5%)
mixed-shape literals across 1000 literals 159 ops/sec [145..173] → 154 ops/sec [146..161] ~ overlap (-3.0%) 521 ops/sec [512..549] → 519 ops/sec [499..523] ~ overlap (-0.4%)
own-class method across 1000 instances 83 ops/sec [81..103] → 89 ops/sec [86..93] ~ overlap (+6.4%) 309 ops/sec [300..318] → 326 ops/sec [312..363] ~ overlap (+5.2%)
inherited method across 1000 instances 90 ops/sec [87..101] → 118 ops/sec [93..136] ~ overlap (+31.4%) 380 ops/sec [349..410] → 357 ops/sec [354..360] ~ overlap (-5.9%)
regexp.js — Interp: 🔴 2, 9 unch. · avg -2.4% · Bytecode: 🟢 1, 🔴 2, 8 unch. · avg -1.4%
Benchmark Interpreted Δ Bytecode Δ
regex literal creation 7,440 ops/sec [6,504..8,188] → 7,055 ops/sec [6,956..9,612] ~ overlap (-5.2%) 184,303 ops/sec [174,065..185,110] → 210,360 ops/sec [206,608..211,704] 🟢 +14.1%
new RegExp(pattern, flags) 7,253 ops/sec [7,024..8,000] → 7,444 ops/sec [6,844..8,652] ~ overlap (+2.6%) 7,442 ops/sec [7,252..7,969] → 6,951 ops/sec [6,771..7,152] 🔴 -6.6%
RegExp(existingRegex) returns the same regex 174,927 ops/sec [156,233..188,939] → 166,252 ops/sec [163,992..206,721] ~ overlap (-5.0%) 270,398 ops/sec [261,075..292,652] → 264,237 ops/sec [258,517..279,607] ~ overlap (-2.3%)
test() on a global regex 54,798 ops/sec [48,609..61,787] → 49,106 ops/sec [48,182..53,429] ~ overlap (-10.4%) 70,644 ops/sec [64,269..80,431] → 65,148 ops/sec [63,996..68,777] ~ overlap (-7.8%)
exec() with capture groups 15,185 ops/sec [14,516..15,815] → 15,407 ops/sec [14,988..15,855] ~ overlap (+1.5%) 16,284 ops/sec [15,428..16,570] → 16,363 ops/sec [16,225..16,918] ~ overlap (+0.5%)
toString() 140,808 ops/sec [140,200..141,140] → 135,232 ops/sec [133,425..163,187] ~ overlap (-4.0%) 207,630 ops/sec [197,119..263,102] → 220,075 ops/sec [209,038..222,661] ~ overlap (+6.0%)
match() with global regex 19,037 ops/sec [18,426..21,817] → 18,274 ops/sec [17,764..18,425] 🔴 -4.0% 26,219 ops/sec [24,556..26,651] → 20,268 ops/sec [20,186..20,390] 🔴 -22.7%
matchAll() with capture groups 9,692 ops/sec [8,890..9,946] → 9,171 ops/sec [8,832..9,711] ~ overlap (-5.4%) 13,294 ops/sec [11,871..14,858] → 12,741 ops/sec [12,313..13,475] ~ overlap (-4.2%)
replace() with global regex 16,737 ops/sec [15,980..20,481] → 15,554 ops/sec [15,529..15,622] 🔴 -7.1% 16,880 ops/sec [16,238..19,008] → 16,577 ops/sec [16,149..17,269] ~ overlap (-1.8%)
search() with regex 35,073 ops/sec [34,685..41,159] → 37,749 ops/sec [37,579..37,971] ~ overlap (+7.6%) 42,364 ops/sec [40,952..46,855] → 46,182 ops/sec [42,836..54,353] ~ overlap (+9.0%)
split() with regex separator 6,900 ops/sec [6,863..6,962] → 7,121 ops/sec [6,883..7,307] ~ overlap (+3.2%) 7,106 ops/sec [6,736..8,295] → 7,088 ops/sec [7,004..7,193] ~ overlap (-0.2%)
strings.js — Interp: 🟢 4, 15 unch. · avg +2.8% · Bytecode: 🟢 3, 16 unch. · avg +0.0%
Benchmark Interpreted Δ Bytecode Δ
string concatenation 110,814 ops/sec [102,646..136,503] → 108,676 ops/sec [107,763..112,323] ~ overlap (-1.9%) 507,265 ops/sec [501,967..532,295] → 471,544 ops/sec [462,924..514,845] ~ overlap (-7.0%)
template literal 199,125 ops/sec [181,496..227,673] → 196,146 ops/sec [192,719..212,981] ~ overlap (-1.5%) 360,699 ops/sec [357,870..361,040] → 366,901 ops/sec [354,265..379,392] ~ overlap (+1.7%)
string repeat 123,307 ops/sec [116,101..191,013] → 139,982 ops/sec [128,948..174,088] ~ overlap (+13.5%) 160,960 ops/sec [154,354..178,064] → 175,602 ops/sec [163,226..182,927] ~ overlap (+9.1%)
split and join 26,153 ops/sec [25,527..28,926] → 29,857 ops/sec [27,816..31,499] ~ overlap (+14.2%) 28,551 ops/sec [27,388..35,708] → 29,121 ops/sec [28,944..32,294] ~ overlap (+2.0%)
indexOf and includes 41,825 ops/sec [40,566..48,990] → 41,034 ops/sec [40,716..43,381] ~ overlap (-1.9%) 46,107 ops/sec [45,717..53,412] → 44,952 ops/sec [43,955..51,667] ~ overlap (-2.5%)
toUpperCase and toLowerCase 64,712 ops/sec [63,210..65,472] → 65,281 ops/sec [64,454..69,955] ~ overlap (+0.9%) 75,969 ops/sec [74,840..100,554] → 78,125 ops/sec [77,529..79,085] ~ overlap (+2.8%)
slice and substring 40,713 ops/sec [40,108..48,902] → 40,769 ops/sec [39,932..41,289] ~ overlap (+0.1%) 53,239 ops/sec [48,501..58,257] → 50,109 ops/sec [47,176..56,096] ~ overlap (-5.9%)
trim operations 56,691 ops/sec [54,772..60,806] → 58,893 ops/sec [58,228..59,109] ~ overlap (+3.9%) 69,366 ops/sec [68,476..74,909] → 75,301 ops/sec [68,029..89,224] ~ overlap (+8.6%)
replace and replaceAll 45,272 ops/sec [43,486..45,770] → 43,892 ops/sec [43,060..44,478] ~ overlap (-3.0%) 46,442 ops/sec [46,057..46,824] → 45,084 ops/sec [43,657..48,669] ~ overlap (-2.9%)
startsWith and endsWith 42,529 ops/sec [36,564..43,377] → 38,947 ops/sec [38,576..42,274] ~ overlap (-8.4%) 40,973 ops/sec [40,203..41,087] → 40,573 ops/sec [40,042..40,795] ~ overlap (-1.0%)
padStart and padEnd 56,871 ops/sec [55,138..59,665] → 58,161 ops/sec [56,845..62,834] ~ overlap (+2.3%) 73,723 ops/sec [63,397..82,850] → 65,473 ops/sec [63,940..66,434] ~ overlap (-11.2%)
identity tag, no substitutions 83,571 ops/sec [83,220..90,064] → 89,377 ops/sec [88,232..92,566] ~ overlap (+6.9%) 148,468 ops/sec [147,889..149,323] → 149,463 ops/sec [148,828..150,769] ~ overlap (+0.7%)
tag with 1 substitution 20,495 ops/sec [20,452..20,554] → 22,239 ops/sec [21,997..22,368] 🟢 +8.5% 30,081 ops/sec [29,681..30,386] → 30,230 ops/sec [28,329..30,870] ~ overlap (+0.5%)
tag with 3 substitutions 11,811 ops/sec [11,653..12,093] → 12,629 ops/sec [12,536..13,248] 🟢 +6.9% 18,225 ops/sec [17,986..20,142] → 18,396 ops/sec [17,749..21,786] ~ overlap (+0.9%)
tag with 6 substitutions 7,046 ops/sec [6,972..7,166] → 7,217 ops/sec [7,119..7,607] ~ overlap (+2.4%) 11,071 ops/sec [11,019..11,118] → 11,240 ops/sec [11,213..11,341] 🟢 +1.5%
String.raw, no substitutions 81,760 ops/sec [81,680..81,960] → 87,185 ops/sec [84,387..88,542] 🟢 +6.6% 83,956 ops/sec [83,331..84,325] → 86,054 ops/sec [85,444..86,318] 🟢 +2.5%
String.raw, 2 substitutions 66,288 ops/sec [65,597..67,010] → 69,991 ops/sec [69,356..77,473] 🟢 +5.6% 68,388 ops/sec [67,567..68,883] → 69,832 ops/sec [69,371..70,392] 🟢 +2.1%
tag accessing .raw array 36,502 ops/sec [33,976..41,388] → 35,149 ops/sec [35,047..35,440] ~ overlap (-3.7%) 43,450 ops/sec [43,254..52,082] → 43,222 ops/sec [42,756..43,479] ~ overlap (-0.5%)
method as tag (this binding) 14,592 ops/sec [14,543..14,644] → 14,902 ops/sec [14,506..17,526] ~ overlap (+2.1%) 21,532 ops/sec [21,456..21,651] → 21,424 ops/sec [21,151..21,865] ~ overlap (-0.5%)
temporal.js — Interp: 🆕 6 · Bytecode: 🆕 6
Benchmark Interpreted Δ Bytecode Δ
PlainDate.add({ months: 1 }) 42,158 ops/sec [40,839..50,559] 🆕 44,316 ops/sec [43,784..47,729] 🆕
PlainDate.until(..., { largestUnit: 'months' }) 50,304 ops/sec [48,255..53,754] 🆕 54,931 ops/sec [54,217..56,218] 🆕
Duration.total days relative to PlainDate 43,255 ops/sec [43,011..43,368] 🆕 44,320 ops/sec [43,486..48,399] 🆕
Duration.round to hours 32,383 ops/sec [31,997..32,670] 🆕 31,766 ops/sec [31,655..32,538] 🆕
ZonedDateTime.from named time zone 8,919 ops/sec [8,913..9,612] 🆕 9,841 ops/sec [9,533..10,560] 🆕
ZonedDateTime.since across DST 10,333 ops/sec [9,181..11,349] 🆕 10,429 ops/sec [9,805..11,388] 🆕
tsv.js — Interp: 🔴 2, 7 unch. · avg -5.8% · Bytecode: 🟢 1, 8 unch. · avg -1.5%
Benchmark Interpreted Δ Bytecode Δ
parse simple 3-column TSV 41,307 ops/sec [38,635..48,119] → 36,538 ops/sec [36,209..46,017] ~ overlap (-11.5%) 42,870 ops/sec [42,512..44,630] → 40,770 ops/sec [40,245..47,394] ~ overlap (-4.9%)
parse 10-row TSV 11,431 ops/sec [10,805..12,474] → 11,439 ops/sec [10,707..12,205] ~ overlap (+0.1%) 11,452 ops/sec [11,242..14,958] → 11,053 ops/sec [10,997..13,330] ~ overlap (-3.5%)
parse 100-row TSV 1,852 ops/sec [1,825..1,955] → 1,908 ops/sec [1,682..2,246] ~ overlap (+3.0%) 2,346 ops/sec [1,769..2,706] → 1,768 ops/sec [1,713..2,116] ~ overlap (-24.6%)
parse TSV with backslash-escaped fields 9,140 ops/sec [8,482..10,587] → 8,028 ops/sec [7,910..8,094] 🔴 -12.2% 8,522 ops/sec [8,414..11,114] → 8,690 ops/sec [8,334..9,991] ~ overlap (+2.0%)
parse without headers (array of arrays) 5,832 ops/sec [5,341..7,224] → 5,003 ops/sec [4,926..5,028] 🔴 -14.2% 5,527 ops/sec [5,489..5,542] → 6,134 ops/sec [5,354..6,883] ~ overlap (+11.0%)
stringify array of objects 33,949 ops/sec [32,416..34,695] → 32,270 ops/sec [32,053..34,001] ~ overlap (-4.9%) 38,139 ops/sec [37,855..38,523] → 43,133 ops/sec [42,173..43,677] 🟢 +13.1%
stringify array of arrays 10,716 ops/sec [10,614..14,002] → 10,343 ops/sec [10,076..12,462] ~ overlap (-3.5%) 11,289 ops/sec [11,057..12,374] → 11,123 ops/sec [11,029..12,915] ~ overlap (-1.5%)
stringify with values needing escaping 28,689 ops/sec [26,630..29,488] → 28,287 ops/sec [27,089..29,650] ~ overlap (-1.4%) 30,982 ops/sec [29,915..38,612] → 30,148 ops/sec [29,859..30,446] ~ overlap (-2.7%)
parse then stringify 6,543 ops/sec [6,381..8,735] → 6,045 ops/sec [5,973..7,267] ~ overlap (-7.6%) 6,687 ops/sec [6,510..7,526] → 6,506 ops/sec [6,417..7,319] ~ overlap (-2.7%)
typed-arrays.js — Interp: 🟢 7, 🔴 3, 12 unch. · avg -1.4% · Bytecode: 🟢 2, 🔴 9, 11 unch. · avg -14.5%
Benchmark Interpreted Δ Bytecode Δ
new Int32Array(0) 95,477 ops/sec [93,477..112,341] → 94,648 ops/sec [93,816..97,961] ~ overlap (-0.9%) 118,763 ops/sec [109,954..148,411] → 108,042 ops/sec [105,567..117,711] ~ overlap (-9.0%)
new Int32Array(100) 89,279 ops/sec [84,208..107,638] → 90,408 ops/sec [88,919..91,432] ~ overlap (+1.3%) 103,621 ops/sec [102,766..116,002] → 106,294 ops/sec [102,186..110,541] ~ overlap (+2.6%)
new Int32Array(1000) 70,094 ops/sec [68,383..71,166] → 75,999 ops/sec [75,343..76,566] 🟢 +8.4% 80,816 ops/sec [80,362..81,130] → 80,675 ops/sec [79,665..81,363] ~ overlap (-0.2%)
new Float64Array(100) 87,585 ops/sec [87,055..88,713] → 89,045 ops/sec [88,741..89,522] 🟢 +1.7% 102,163 ops/sec [101,438..109,333] → 102,889 ops/sec [102,337..103,088] ~ overlap (+0.7%)
Int32Array.from([...]) 1,484 ops/sec [1,376..1,496] → 1,475 ops/sec [1,448..1,504] ~ overlap (-0.6%) 1,493 ops/sec [1,424..1,503] → 1,417 ops/sec [1,405..1,419] 🔴 -5.1%
Int32Array.of(1, 2, 3, 4, 5) 64,998 ops/sec [64,865..65,325] → 64,314 ops/sec [63,631..65,632] ~ overlap (-1.1%) 74,134 ops/sec [73,158..75,414] → 74,008 ops/sec [71,659..74,820] ~ overlap (-0.2%)
sequential write 100 elements 761 ops/sec [737..784] → 792 ops/sec [765..848] ~ overlap (+4.1%) 1,529 ops/sec [1,505..1,739] → 1,540 ops/sec [1,526..1,562] ~ overlap (+0.7%)
sequential read 100 elements 811 ops/sec [808..813] → 843 ops/sec [829..1,037] 🟢 +4.0% 1,625 ops/sec [1,594..1,633] → 1,674 ops/sec [1,653..1,912] 🟢 +3.0%
Float64Array write 100 elements 738 ops/sec [732..843] → 767 ops/sec [761..774] ~ overlap (+4.0%) 1,430 ops/sec [1,393..1,435] → 1,417 ops/sec [1,301..1,448] ~ overlap (-0.9%)
fill(42) 1,691 ops/sec [1,660..1,767] → 1,513 ops/sec [1,500..2,078] ~ overlap (-10.5%) 1,743 ops/sec [1,687..1,893] → 1,707 ops/sec [1,636..1,753] ~ overlap (-2.1%)
slice() 7,482 ops/sec [7,373..7,508] → 7,237 ops/sec [7,138..8,450] ~ overlap (-3.3%) 7,598 ops/sec [7,454..8,153] → 7,836 ops/sec [7,585..7,882] ~ overlap (+3.1%)
map(x => x * 2) 1,375 ops/sec [1,348..1,419] → 1,463 ops/sec [1,460..1,469] 🟢 +6.4% 1,889 ops/sec [1,875..1,912] → 1,986 ops/sec [1,948..2,165] 🟢 +5.1%
filter(x => x > 50) 1,446 ops/sec [1,432..1,458] → 1,631 ops/sec [1,516..1,877] 🟢 +12.8% 3,577 ops/sec [3,572..3,603] → 2,159 ops/sec [2,133..2,176] 🔴 -39.7%
reduce (sum) 1,415 ops/sec [1,404..1,422] → 1,576 ops/sec [1,561..1,580] 🟢 +11.4% 3,507 ops/sec [3,487..3,516] → 2,079 ops/sec [2,064..2,099] 🔴 -40.7%
sort() 13,953 ops/sec [13,346..17,956] → 12,740 ops/sec [12,582..13,087] 🔴 -8.7% 25,983 ops/sec [25,797..26,093] → 14,638 ops/sec [14,600..14,845] 🔴 -43.7%
indexOf() 28,054 ops/sec [27,081..29,687] → 27,130 ops/sec [27,088..27,189] ~ overlap (-3.3%) 47,394 ops/sec [46,843..47,922] → 28,897 ops/sec [28,607..29,086] 🔴 -39.0%
reverse() 25,193 ops/sec [14,252..25,272] → 13,019 ops/sec [12,463..13,582] 🔴 -48.3% 26,395 ops/sec [26,325..26,418] → 15,097 ops/sec [14,885..15,142] 🔴 -42.8%
create view over existing buffer 156,897 ops/sec [156,424..157,901] → 101,276 ops/sec [97,545..101,861] 🔴 -35.5% 200,981 ops/sec [200,544..202,423] → 129,558 ops/sec [122,714..137,748] 🔴 -35.5%
subarray() 59,980 ops/sec [59,902..91,130] → 59,695 ops/sec [58,821..60,155] ~ overlap (-0.5%) 106,202 ops/sec [105,346..106,564] → 66,373 ops/sec [64,750..71,137] 🔴 -37.5%
set() from array 62,368 ops/sec [61,888..62,765] → 61,812 ops/sec [59,984..65,163] ~ overlap (-0.9%) 127,664 ops/sec [126,883..127,864] → 127,688 ops/sec [74,397..128,950] ~ overlap (+0.0%)
for-of loop 2,495 ops/sec [1,552..2,548] → 2,842 ops/sec [1,574..2,901] ~ overlap (+13.9%) 12,711 ops/sec [12,632..12,812] → 12,872 ops/sec [7,368..13,041] ~ overlap (+1.3%)
spread into array 10,087 ops/sec [6,642..10,174] → 11,646 ops/sec [11,601..11,663] 🟢 +15.5% 37,557 ops/sec [36,920..38,139] → 23,117 ops/sec [22,868..23,298] 🔴 -38.4%
uint8array-encoding.js — Interp: 🟢 9, 🔴 1, 8 unch. · avg +7.6% · Bytecode: 🟢 4, 🔴 4, 10 unch. · avg +7.2%
Benchmark Interpreted Δ Bytecode Δ
short (5 bytes) 120,048 ops/sec [119,256..120,347] → 128,598 ops/sec [121,887..140,205] 🟢 +7.1% 151,014 ops/sec [148,175..151,931] → 156,034 ops/sec [155,243..165,481] 🟢 +3.3%
medium (450 bytes) 91,437 ops/sec [90,758..91,935] → 92,540 ops/sec [88,223..100,830] ~ overlap (+1.2%) 104,915 ops/sec [103,800..109,322] → 104,795 ops/sec [101,779..114,833] ~ overlap (-0.1%)
large (4096 bytes) 29,429 ops/sec [28,928..29,906] → 28,015 ops/sec [27,777..28,210] 🔴 -4.8% 30,079 ops/sec [29,858..30,128] → 29,958 ops/sec [29,482..30,484] ~ overlap (-0.4%)
base64url alphabet 70,466 ops/sec [69,650..70,918] → 77,903 ops/sec [72,711..84,035] 🟢 +10.6% 72,519 ops/sec [72,119..72,702] → 72,837 ops/sec [71,541..73,285] ~ overlap (+0.4%)
omitPadding 87,887 ops/sec [86,356..88,016] → 91,488 ops/sec [90,534..105,826] 🟢 +4.1% 95,771 ops/sec [93,663..97,433] → 99,734 ops/sec [98,308..100,052] 🟢 +4.1%
short (8 chars) 109,375 ops/sec [107,084..109,401] → 111,301 ops/sec [106,628..114,873] ~ overlap (+1.8%) 134,531 ops/sec [127,596..140,474] → 130,818 ops/sec [128,097..132,299] ~ overlap (-2.8%)
medium (600 chars) 61,088 ops/sec [59,319..61,492] → 61,120 ops/sec [60,496..61,527] ~ overlap (+0.1%) 69,384 ops/sec [65,186..91,145] → 66,560 ops/sec [65,533..66,893] ~ overlap (-4.1%)
large (5464 chars) 13,595 ops/sec [13,309..14,073] → 13,539 ops/sec [13,274..13,618] ~ overlap (-0.4%) 14,879 ops/sec [14,532..16,076] → 13,825 ops/sec [13,305..13,991] 🔴 -7.1%
short (5 bytes) 121,412 ops/sec [119,930..122,363] → 124,430 ops/sec [123,063..129,648] 🟢 +2.5% 161,456 ops/sec [156,933..162,180] → 161,843 ops/sec [161,568..163,857] ~ overlap (+0.2%)
medium (450 bytes) 83,407 ops/sec [82,568..95,355] → 82,492 ops/sec [81,760..83,582] ~ overlap (-1.1%) 98,916 ops/sec [97,962..100,186] → 163,924 ops/sec [95,463..165,251] ~ overlap (+65.7%)
large (4096 bytes) 22,344 ops/sec [21,596..24,055] → 23,501 ops/sec [23,338..23,526] ~ overlap (+5.2%) 23,123 ops/sec [22,291..23,507] → 38,115 ops/sec [37,916..38,346] 🟢 +64.8%
short (10 chars) 116,551 ops/sec [114,872..117,335] → 117,148 ops/sec [116,963..117,807] ~ overlap (+0.5%) 152,145 ops/sec [138,240..157,825] → 193,276 ops/sec [143,813..228,008] ~ overlap (+27.0%)
medium (900 chars) 81,767 ops/sec [81,435..81,998] → 89,039 ops/sec [88,278..89,848] 🟢 +8.9% 113,279 ops/sec [99,065..167,841] → 99,599 ops/sec [97,769..102,895] ~ overlap (-12.1%)
large (8192 chars) 24,074 ops/sec [22,863..24,549] → 28,838 ops/sec [27,903..31,149] 🟢 +19.8% 49,451 ops/sec [49,398..49,563] → 47,461 ops/sec [26,186..48,819] 🔴 -4.0%
setFromBase64 (450 bytes) 50,066 ops/sec [49,844..50,682] → 53,974 ops/sec [49,699..81,184] ~ overlap (+7.8%) 89,445 ops/sec [89,296..90,161] → 89,937 ops/sec [89,414..90,882] ~ overlap (+0.6%)
setFromHex (450 bytes) 20,334 ops/sec [20,193..27,122] → 32,728 ops/sec [32,677..32,771] 🟢 +61.0% 36,038 ops/sec [35,828..36,102] → 36,507 ops/sec [36,384..36,833] 🟢 +1.3%
toBase64 → fromBase64 (450 bytes) 66,952 ops/sec [66,745..67,509] → 69,675 ops/sec [69,533..69,838] 🟢 +4.1% 73,582 ops/sec [73,375..73,966] → 70,007 ops/sec [69,866..70,380] 🔴 -4.9%
toHex → fromHex (450 bytes) 82,368 ops/sec [82,184..82,688] → 89,489 ops/sec [88,842..89,778] 🟢 +8.6% 91,354 ops/sec [90,637..91,789] → 88,611 ops/sec [88,424..89,496] 🔴 -3.0%
weak-collections.js — Interp: 🔴 8, 7 unch. · avg -5.7% · Bytecode: 🟢 4, 11 unch. · avg +14.7%
Benchmark Interpreted Δ Bytecode Δ
constructor from 50 entries 10,067 ops/sec [9,880..10,577] → 9,872 ops/sec [9,575..11,160] ~ overlap (-1.9%) 9,910 ops/sec [9,806..10,026] → 9,711 ops/sec [9,598..9,928] ~ overlap (-2.0%)
set 50 object keys 2,509 ops/sec [2,470..2,524] → 2,539 ops/sec [2,516..2,565] ~ overlap (+1.2%) 3,581 ops/sec [3,535..3,581] → 3,634 ops/sec [3,573..3,667] ~ overlap (+1.5%)
get lookups (50 entries) 42,436 ops/sec [42,104..45,337] → 42,049 ops/sec [41,692..43,121] ~ overlap (-0.9%) 78,439 ops/sec [76,343..86,711] → 78,386 ops/sec [77,700..82,892] ~ overlap (-0.1%)
has checks (50 entries) 56,636 ops/sec [56,459..57,038] → 53,340 ops/sec [53,182..53,453] 🔴 -5.8% 96,676 ops/sec [95,503..100,040] → 98,967 ops/sec [96,747..100,337] ~ overlap (+2.4%)
delete entries 2,433 ops/sec [2,373..2,437] → 2,319 ops/sec [2,302..2,351] 🔴 -4.7% 3,514 ops/sec [3,495..3,523] → 3,561 ops/sec [3,546..3,581] 🟢 +1.3%
non-registered symbol keys 5,856 ops/sec [5,832..5,884] → 5,636 ops/sec [5,571..5,767] 🔴 -3.8% 8,357 ops/sec [8,200..8,563] → 8,468 ops/sec [8,399..8,491] ~ overlap (+1.3%)
getOrInsert 2,429 ops/sec [2,424..2,447] → 2,397 ops/sec [2,372..2,419] 🔴 -1.3% 3,268 ops/sec [3,157..3,529] → 3,408 ops/sec [3,380..3,414] ~ overlap (+4.3%)
getOrInsertComputed 1,349 ops/sec [1,321..1,360] → 1,290 ops/sec [1,281..1,295] 🔴 -4.4% 1,700 ops/sec [1,680..1,786] → 1,759 ops/sec [1,751..1,766] ~ overlap (+3.5%)
forced gc live-key retention 65 ops/sec [45..85] → 91 ops/sec [68..112] ~ overlap (+39.3%) 153 ops/sec [125..166] → 111 ops/sec [70..136] ~ overlap (-27.3%)
constructor from 50 values 11,747 ops/sec [11,317..12,184] → 11,753 ops/sec [11,490..13,102] ~ overlap (+0.1%) 11,956 ops/sec [11,650..12,158] → 12,075 ops/sec [11,839..17,713] ~ overlap (+1.0%)
add 50 object values 2,771 ops/sec [2,724..2,805] → 2,746 ops/sec [2,721..2,767] ~ overlap (-0.9%) 3,896 ops/sec [3,766..4,042] → 3,793 ops/sec [3,739..3,822] ~ overlap (-2.6%)
has checks (50 values) 55,523 ops/sec [55,271..88,215] → 53,401 ops/sec [52,471..53,637] 🔴 -3.8% 98,502 ops/sec [97,128..99,705] → 164,776 ops/sec [99,449..166,058] ~ overlap (+67.3%)
delete values 14,833 ops/sec [14,763..14,869] → 9,149 ops/sec [8,876..9,551] 🔴 -38.3% 10,759 ops/sec [10,375..11,191] → 16,212 ops/sec [15,838..16,310] 🟢 +50.7%
non-registered symbol values 9,988 ops/sec [9,836..10,009] → 6,235 ops/sec [6,172..6,443] 🔴 -37.6% 8,628 ops/sec [8,468..8,686] → 14,641 ops/sec [14,554..14,742] 🟢 +69.7%
forced gc pruning smoke 178 ops/sec [92..230] → 137 ops/sec [79..148] ~ overlap (-23.0%) 137 ops/sec [116..159] → 205 ops/sec [178..239] 🟢 +49.3%

Deterministic profile diff

atomics

  • 🆕 Profile added in current run.

intl

  • 🆕 Profile added in current run.

temporal

  • 🆕 Profile added in current run.

Measured on ubuntu-latest x64. Benchmark ranges compare cached main-branch min/max ops/sec with the PR run; overlapping ranges are treated as unchanged noise. Percentage deltas are secondary context.

@frostney frostney merged commit 5319ade into main Jun 24, 2026
13 of 14 checks passed
@frostney frostney deleted the codex/indexed-data-runtime-module-loader branch June 24, 2026 17:38
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

internal Refactoring, CI, tooling, cleanup

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant