Skip to content

perf(vm): skip coverage and limit polls on production dispatch - #1216

Open
frostney wants to merge 2 commits into
perf/w1-fused-opsfrom
perf/w2-prod-dispatch
Open

perf(vm): skip coverage and limit polls on production dispatch#1216
frostney wants to merge 2 commits into
perf/w1-fused-opsfrom
perf/w2-prod-dispatch

Conversation

@frostney

@frostney frostney commented Aug 26, 2026

Copy link
Copy Markdown
Owner

Summary

  • Split ExecuteRegisters into a production loop and an instrumented loop that share one opcode case via Goccia.VM.DispatchCase.inc. The production path omits stop-IP, coverage, opcode profiling, and inactive instruction-limit polls.
  • Middle layer of the bytecode-vs-QuickJS stack (#1215#1216#1217).
  • Non-goals: splitting hot vs cold opcodes, duplicating the full case (FPC “Procedure too complex”), changing observable VM semantics.

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

Full interpreter + bytecode JS suite and Pascal unit tests were run on stack tip 629087c8. Docs updates: docs/bytecode-vm.md, docs/embedding.md, docs/profiling.md, docs/testing.md. Combined A/B vs the wave-1 head (/tmp/combined-w2-prod-dispatch-ab.json): loop-dispatch-floor 0.960, Richards 0.961, Bounce 0.985, geomean 0.958; checksums matched.

frostney and others added 2 commits August 26, 2026 02:44
Prod bytecode dispatch now uses a dedicated loop head that skips
stop-IP, coverage, opcode profiling, and instruction-limit polling,
sharing one opcode case with the instrumented path.

Co-authored-by: Cursor <cursoragent@cursor.com>
Accepted isolated lane on optimize/w2-prod-dispatch. Prod ExecuteRegisters
skips stop-IP, coverage, profiler, and inactive instruction-limit polls
while sharing one opcode case with the instrumented path.
@coderabbitai

coderabbitai Bot commented Aug 26, 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 Plus

Run ID: 013d0d25-86a3-4384-9527-007a977c72ff

📥 Commits

Reviewing files that changed from the base of the PR and between 48dcbd9 and a8af171.

📒 Files selected for processing (8)
  • docs/bytecode-vm.md
  • docs/embedding.md
  • docs/profiling.md
  • docs/testing.md
  • source/units/Goccia.InstructionLimit.Test.pas
  • source/units/Goccia.InstructionLimit.pas
  • source/units/Goccia.VM.DispatchCase.inc
  • source/units/Goccia.VM.pas

Included review availability: 3 reviews are currently available. Your included PR review attempts over the past 7 days set your current allowance at 5 reviews per hour.


📝 Walkthrough

Walkthrough

Changes

Instruction-limit dispatch behavior

Layer / File(s) Summary
Instruction-limit activity API and state tests
source/units/Goccia.InstructionLimit.pas, source/units/Goccia.InstructionLimit.Test.pas
Adds InstructionLimitIsActive and verifies state changes through a captured handle.
Selectable dispatch loop documentation
docs/bytecode-vm.md, docs/embedding.md, docs/profiling.md, docs/testing.md
Documents production dispatch without per-instruction polling and instrumented dispatch when profiling, coverage, stop-IP, or instruction-limit checks are active.

Estimated code review effort: 1 (Trivial) | ~5 minutes

Merge Risk: ⚪ Minimal · up to a8af1

The production dispatch path removes inactive instrumentation polls while preserving the shared opcode behavior; no actionable merge-blocking risk remains after normal checks and review.

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Description check ✅ Passed The description includes the required Summary and Testing sections. It explains the implementation, constraints, non-goals, related stack references, test coverage, documentation updates, and benchmar…
Title check ✅ Passed The title is concise and accurately describes the main performance change: production dispatch skips coverage and instruction-limit polling.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check. Docstring coverage is scoped to functions touched by this diff. Analyzed 0 functions across 0…
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.
Full details: Description check

Explanation

The description includes the required Summary and Testing sections. It explains the implementation, constraints, non-goals, related stack references, test coverage, documentation updates, and benchmark results.

Full details: Docstring Coverage

Explanation

No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check. Docstring coverage is scoped to functions touched by this diff. Analyzed 0 functions across 0 files. (6 skipped: 6 unsupported.)


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

@vercel

vercel Bot commented Aug 26, 2026

Copy link
Copy Markdown

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

Project Deployment Actions Updated (UTC)
gocciascript-homepage Building Building Preview Aug 26, 2026 1:44pm

Request Review

@frostney frostney changed the title perf/w2 prod dispatch perf(vm): skip coverage and limit polls on production dispatch Aug 26, 2026
@github-actions

Copy link
Copy Markdown
Contributor

Web Tooling Benchmark

Workload Status Goccia
acorn pass 0.03 runs/s
babel pass 0.01 runs/s
babel-minify pass 0.15 runs/s
babylon pass 0.04 runs/s
buble pass 0.09 runs/s
chai pass 0.07 runs/s
coffeescript pass 0.01 runs/s
espree pass 0.02 runs/s
esprima pass 0.05 runs/s
jshint pass 0.01 runs/s
lebab pass 0.09 runs/s
postcss pass 0.02 runs/s
prepack pass 0.10 runs/s
prettier pass 0.06 runs/s
source-map pass 0.03 runs/s
terser pass 0.28 runs/s
typescript pass 0.11 runs/s
uglify-js pass 0.05 runs/s

18 pinned Web Tooling workloads; 18 workloads produced at least one Goccia sample. Raw results from 1 sample per workload; full stdout/stderr for failures and min/max/CV stay in the web-tooling-report artifact. This lane is Goccia-only by design.

@github-actions

Copy link
Copy Markdown
Contributor

Suite Timing

Test Runner (interpreted: 12,813 passed; bytecode: 12,813 passed)
Metric Interpreted Bytecode
Total 12813 12813
Passed 12813 ✅ 12813 ✅
Workers 4 4
Test Duration 15.54s 21.87s
Lex (cumulative) 1.46s 2.26s
Parse (cumulative) 766.8ms 1.17s
Compile (cumulative) 1.51s
Execute (cumulative) 447.0ms 21.45s
Engine Total (cumulative) 2.68s 26.39s
Lex (avg/worker) 365.7ms 564.3ms
Parse (avg/worker) 191.7ms 293.6ms
Compile (avg/worker) 377.5ms
Execute (avg/worker) 111.7ms 5.36s
Engine Total (avg/worker) 669.1ms 6.60s

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 56.05 MiB 59.40 MiB
GC Peak Live 201.64 MiB 174.91 MiB
GC Allocated During Run 702.14 MiB 613.17 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 1,004 1,010
GC Collected Objects 5,498,876 4,734,294
Heap Start Allocated 372.2 KiB 372.2 KiB
Heap End Allocated 2.99 MiB 3.00 MiB
Heap Delta Allocated 2.63 MiB 2.63 MiB
Heap Delta Free 2.21 MiB 2.21 MiB
Benchmarks (interpreted: 440; bytecode: 440)
Metric Interpreted Bytecode
Total 440 440
Workers 4 4
Duration 3.11min 2.92min

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 85.0 KiB 85.0 KiB
GC Peak Live 568.83 MiB 399.03 MiB
GC Allocated During Run 19.72 GiB 13.57 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 7,425 5,942
GC Collected Objects 211,189,900 181,252,206
Heap Start Allocated 1.37 MiB 1.37 MiB
Heap End Allocated 1.37 MiB 1.37 MiB
Heap Delta Allocated 3.2 KiB 3.2 KiB
Boot
Metric Interpreted Bytecode
Boot (median) 7.6ms 7.7ms
Boot (min) 7.5ms 7.6ms

Empty-script (0;) end-to-end process wall-clock for GocciaScriptLoader, min and median over 60 runs after 10 warmups. Includes a fixed process / dynamic-loader floor that does not shrink, so it understates the engine-boot speedup; treat as practical boot time, not pure engine work.

Measured on ubuntu-latest x64.

@github-actions

Copy link
Copy Markdown
Contributor

Benchmark Results

440 benchmarks · PR vs same-runner main build

Interpreted: 🟢 22 improved · 🔴 34 regressed · 384 unchanged · avg +0.2%
Bytecode: 🟢 67 improved · 🔴 14 regressed · 359 unchanged · avg +1.1%

Typical per-run noise (median variance): interpreted ±1.7%, bytecode ±1.4%. Deltas within noise overlap and read as unchanged.

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

Deterministic profile diff

Deterministic profile diff: no significant changes.

Measured on ubuntu-latest x64. Each PR run also builds the main base and benchmarks it back-to-back on the same runner after a warm-up discard, so the ranges compare two runs measured under the same conditions; overlapping min/max ranges are treated as unchanged noise. Percentage deltas are secondary context. See docs/adr/0076.

@github-actions

Copy link
Copy Markdown
Contributor

JetStream 3 Performance Barometer

Workload Status Goccia main Goccia PR QuickJS Node.js vs QuickJS vs Node.js
hash-map pass 0.56 0.56 13.52 342.63 24.30× 615.90×
ai-astar pass 1.72 1.73 48.90 354.49 28.23× 204.62×
gaussian-blur pass 0.36 0.36 8.00 295.88 22.50× 831.81×
raytrace-public-class-fields pass 0.43 0.44 11.56 202.90 26.23× 460.16×
sync-fs pass 1.18 1.19 39.89 276.61 33.55× 232.65×
lazy-collections pass 2.16 2.23 71.10 154.78 31.91× 69.46×

Geomean reference ratio: QuickJS 27.51×; Node.js 303.37×.

1.00× means aligned; values above 1.00× mean Goccia was proportionally slower after normalizing JetStream’s higher-is-better score. This is a directional barometer across runtimes with different goals, not a product ranking. Raw samples and failure details remain in the jetstream-report artifact.

@github-actions

Copy link
Copy Markdown
Contributor

test262 Conformance

12 timeout(s) — counted separately from ordinary conformance failures; inspect the full artifact for affected tests.

Category Run Passed Δ Pass Failed Timeouts Δ Timeout Wrap-Infra Pass-rate Δ Rate
built-ins 23,812 23,719 ±0 93 0 ±0 0 99.6% ±0pp
harness 116 116 ±0 0 0 ±0 0 100.0% ±0pp
intl402 3,357 3,344 ±0 12 1 ±0 0 99.6% ±0pp
language 23,724 23,717 ±0 7 0 ±0 0 100.0% ±0pp
staging 1,483 1,387 -1 85 11 +1 0 93.5% -0.1pp
total 52,492 52,283 -1 197 12 +1 0 99.6% ±0pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
language/expressions 100.0% ±0pp 11,101 / 11,102
intl402/Temporal 100.0% ±0pp 2,028 / 2,029
language/statements 99.9% ±0pp 9,341 / 9,347
Per-test deltas (+0 / -0 / timeout +2 / -1)

New timeouts (2):

  • staging/sm/regress/regress-610026.js
  • staging/sm/TypedArray/element-setting-converts-using-ToNumber.js

Resolved timeouts (1):

  • staging/sm/extensions/recursion.js

Steady-state failures and timeouts are non-blocking; PASS → non-timeout failure transitions 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.

@github-actions

Copy link
Copy Markdown
Contributor

AWFY Results

Target Status Goccia main Goccia PR QuickJS 2026-06-04 NodeJS v26.7.0 Δ PR vs main
Bounce pass 20.82ms 21.03ms 1.05ms 1.09ms ~ overlap (-0.99%)
CD pass 226.69ms 222.36ms 10.71ms 9.63ms ~ overlap (+1.91%)
DeltaBlue pass 4.92ms 4.96ms 306.36µs 1.85ms ~ overlap (-0.63%)
Havlak pass 86.99s 87.04s 4299.67ms 188.02ms ~ overlap (-0.06%)
Json pass 379.00ms 376.60ms 14.39ms 4.57ms ~ overlap (+0.63%)
List pass 15.41ms 15.39ms 1.04ms 0.78ms ~ overlap (+0.16%)
Mandelbrot pass 31.84µs 30.82µs 5.03µs 93.10µs 🟢 +3.21%
NBody pass 415.78µs 409.97µs 27.52µs 394.95µs ~ overlap (+1.40%)
Permute pass 42.98ms 43.55ms 1.87ms 0.74ms ~ overlap (-1.34%)
Queens pass 22.91ms 22.91ms 1.26ms 1.04ms ~ overlap (+0.03%)
Richards pass 781.43ms 778.01ms 51.94ms 6.89ms ~ overlap (+0.44%)
Sieve pass 13.80ms 13.74ms 0.57ms 0.58ms ~ overlap (+0.46%)
Storage pass 39.58ms 39.76ms 2.96ms 1.00ms 🔴 -0.46%
Towers pass 57.83ms 59.03ms 3.15ms 1.19ms 🔴 -2.08%

Geomean Ratios

Ratio (row / column) Goccia main Goccia PR QuickJS 2026-06-04 NodeJS v26.7.0
Goccia main 1.000 1.002 17.161 20.408
Goccia PR 0.998 1.000 17.127 20.367
QuickJS 2026-06-04 0.058 0.058 1.000 1.189
NodeJS v26.7.0 0.049 0.049 0.841 1.000

14 pinned AWFY benchmarks. Medians from 5 interleaved samples per engine; raw JSON includes min/max/CV and is attached as the awfy-report artifact. Δ compares PR Goccia median against the same-runner main Goccia median; overlapping min/max ranges are treated as unchanged noise. Rows below 0.5ms are timer-floor sensitive.

@frostney
frostney marked this pull request as ready for review August 26, 2026 14:42
@frostney

Copy link
Copy Markdown
Owner Author

@coderabbitai review

@coderabbitai

coderabbitai Bot commented Aug 26, 2026

Copy link
Copy Markdown
Contributor
✅ Action performed

Review finished.

Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits. This command is applicable only when automatic reviews are paused.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant