TL;DR
Zoo.js provides a detailed, tabular comparison of dozens of JavaScript engines, listing scores, code size, implementation language, JIT status, ECMAScript support and project metadata. The dataset includes mainstream browser engines (V8, JavaScriptCore, SpiderMonkey) as well as many embeddable, experimental and language-specific engines.
What happened
The site zoo.js aggregates a comprehensive comparison table of JavaScript engines and related runtimes as of the published snapshot. Each row lists an engine along with a numeric score, binary and source sizes, implementation language, whether a JIT is present, years of active development, ECMAScript target/version support, repository stars, contributor counts, owning organization and license, plus a short description. The table covers major browser engines—V8 (Chrome/Node.js), JavaScriptCore (Safari/WebKit) and SpiderMonkey (Firefox)—alongside JVM targets like GraalJS, embeddable C engines such as QuickJS and Duktape, mobile/React Native engines like Hermes, microcontroller-focused engines including JerryScript and XS, and many experimental or hobbyist implementations. The data rows include per-engine metrics such as ES compatibility percentages and project popularity indicators (stars, contributors).
Why it matters
- Developers and integrators can compare engines by footprint, language and ES-version support when choosing an engine for browsers, servers, native apps or constrained devices.
- The table highlights a wide diversity of implementations—C/C++, Java, Rust, Go, Zig and others—reflecting different trade-offs between performance, portability and embedability.
- Project metadata (stars, contributors, license, organization) helps assess community activity and reuse constraints for production or research use.
- ES-version compatibility percentages let teams gauge how well engines track modern ECMAScript features versus legacy support.
Key facts
- JavaScriptCore (Safari/WebKit) is listed with a score of 61,449, implemented in C++, and licensed under LGPL-2.0; the row shows high ESnext compatibility.
- V8 (Chrome, Node.js) appears with a score of 58,906, written in C++, licensed BSD-3, and shows near-complete ESnext support; it has 24.7k repository stars and 1,196 contributors in the table.
- SpiderMonkey (Firefox) is in the table with a score of 23,855, implemented in C++ and licensed MPL-2.0; ESnext support is indicated as complete.
- QuickJS, a lightweight C engine by Fabrice Bellard and Charlie Gordon, is listed with a score of 1,637 and shows full ES2023 support in the snapshot.
- GraalJS is represented as a Java-based engine for the JVM/GraalVM (score 27,355) and is licensed under GFTC/UPL-1.0.
- Hermes and Hermes V1 (Facebook) are included as engines focused on mobile use; Hermes shows ES2023 coverage and appears as an engine used for React Native scenarios.
- There are multiple language-specific or experimental engines: engine262 (TypeScript, score 1) aims full ECMAScript spec implementation, and several Rust and Go engines are listed (Boa, Brimstone, goja, etc.).
- Many embeddable and microcontroller-targeted engines are enumerated, including JerryScript, Duktape, XS, and MuJS, with different ES compatibility levels and small code footprints.
- The table shows both mainstream engines and dozens of forks, research projects and tiny interpreters, with per-project details such as stars and contributor counts to indicate activity.
What to watch next
- Multiple engines written in Rust and Go appear in the dataset (Boa, Brimstone, goja, Sobek, ModerncQuickJS), suggesting growing diversity in implementation languages within the ecosystem.
- QuickJS and its community forks (QuickJS-NG, ModerncQuickJS, PrimJS and QuickJIT variants) are prominent in the listing and bear watching for embeddable use cases and performance experiments.
- Future trajectories for engine performance, JIT adoption across smaller engines, or consolidation among implementations are not confirmed in the source.
Quick glossary
- JavaScript engine: A software component that parses, interprets and/or compiles JavaScript code and executes it on a platform.
- JIT (Just-In-Time) compiler: A runtime component that compiles code to machine code on the fly to improve execution speed compared with interpretation.
- ECMAScript (ES): The standardized specification for JavaScript; versions include ES5, ES6 (ES2015) and later yearly releases.
- LOC (Lines of Code): A rough measure of source size used to indicate project scale or complexity.
- AOT (Ahead-Of-Time) compilation: Compiling code to native binaries before execution, as an alternative to JIT compilation at runtime.
Reader FAQ
What is the zoo.js page?
A comparative table that lists many JavaScript engines and runtimes along with metrics like scores, sizes, language, JIT status, ES support, stars and license information.
Which engines are used by major browsers?
The table identifies V8 (Chrome, Node.js), JavaScriptCore (Safari/WebKit) and SpiderMonkey (Firefox); ChakraCore is listed as the engine of Microsoft Edge Legacy.
Does the table show ECMAScript compatibility?
Yes — the dataset includes percentage indicators of ES1–5, ES6 and ES2016+ (or similar ES-year groupings) and a target ES version per engine.
Which engine is most compliant with the spec?
Not confirmed in the source; the table lists per-engine ES compatibility percentages but does not rank overall compliance beyond the shown numbers.
Engine Score Binary LOC Language JIT Years Target ES1-5 ES6 ES2016+ Stars Contributors Org License Description Richards DeltaBlue Crypto RayTrace EarleyBoyer RegExp Splay NavierStokes JavaScriptCore 2025-12-06 (304071) 61449 28M 770K…
Sources
- JavaScript engines zoo – Compare every JavaScript engine
- JavaScript Engines Explained—Comparing V8 …
- JavaScript engines zoo | Lobsters
- List of JavaScript engines
Related posts
- pixoo-rb: Ruby client to drive Pixoo 64 LED sign with images, text
- Gershwin: a lightweight GNUstep desktop offering an early Mac OS X feel
- Corundum: Open-source FPGA-based NIC and platform for in‑network compute