Your code runs on an engine inside a host, but neither one defines the language: a specification does.
Most people who write JavaScript run it in a browser tab or with node file.js. But JavaScript runs in far more places than those two. There are engines built for microcontrollers with mere kilobytes of memory; engines written in Rust, Go, and Java to sit inside programs in those languages; an engine written in JavaScript itself; and compilers that turn JavaScript into a native binary with no engine in it at all. The JavaScript engines zoo catalogs more than a hundred of them.1
This post is the vocabulary for that list: what an engine is, what a runtime is, and why there are so many of both.
What is JavaScript?
JavaScript is defined by a document, not by a program or a single reference implementation.
JavaScript's formal name is ECMAScript (ES), and it's defined by a specification, ECMA-262. TC39 (Ecma International's Technical Committee 39) writes it in the open on GitHub, and (these days) Ecma publishes a dated edition annually. The current one is ECMAScript 2026, the 17th edition.2
Next to the specification sits test262, the official test suite: over 50,000 small tests for the language and its internationalization API.3 TC39 maintains the two as separate things. One says what the language is, and the other checks an implementation against it. Many engines implement the specification and test themselves against the suite.
Things didn't start off this way. In the beginning, there was only one implementation: Mocha (later LiveScript), written by Brendan Eich at Netscape in 1995. The language was renamed JavaScript in December 1995 and shipped in Netscape Navigator 2.0 the following March. Meanwhile, folks at Microsoft were working on what would become JScript—in essence, Internet Explorer's answer to Netscape's JavaScript. Within the language's first year, according to Allen Wirfs-Brock and Brendan Eich's history of it, web developers were already "encountering interoperability issues between Netscape's JavaScript and Microsoft's reverse-engineered implementation."4 Two browsers, two engines, and pages that behaved differently in each. Standardization began at Ecma International in 1996, and the first standard, under the name ECMAScript, came out in 1997.4 The timeline below runs from there to ESNext (the informal name for whatever comes next).5
For the fuller story, there's Wirfs-Brock and Eich's paper itself;4 and Deno's "A brief history of JavaScript," which covers much more than the editions: browsers, runtimes, and tooling.6
For some languages, the main implementation effectively is the language. Rust has a specification team, and, in 2025, the Rust project adopted a specification, the FLS (originally the Ferrocene Language Specification). But the FLS describes Rust "as implemented by the Rust compiler (rustc)," and, when in doubt, it "prefers documenting behavior of rustc over claiming correctness as a specification."7
JavaScript isn't like that. No engine is JavaScript. Most of us use more than one engine in a day: V8 in Chrome on a laptop, JavaScriptCore in Safari on a phone. Any program that runs JavaScript the way ECMA-262 describes (conforms to the specification) is a JavaScript engine—whatever it's written in, however small it is, and wherever it runs.
JavaScript isn't alone in that shape. C has a standard, ISO/IEC 9899; and many compilers, among them GCC (the GNU Compiler Collection) and Clang. SQL has one too, ISO/IEC 9075; and many databases that each implement it a little differently.8 Rust isn't the only language defined in practice by one implementation, either. Perl 5 is the classic case: its documentation follows its interpreter, lowercase perl, rather than the other way around, and the old truism is "Only perl can parse Perl."9
Where console.log comes from
ECMA-262 is narrower than you might expect. The specification defines numbers, strings, objects, functions, typed arrays, and the rest of the language. It does not define a way to read a file, open a network connection, print to a terminal, or load another file by name.10 There's no input or output in it at all.11
That includes console.log, and the devtools console in your browser: neither is part of the language. Nor are fetch, setTimeout, or require.
Those come from whatever program is running the code. An engine always lives inside something that supplies the rest: its host (some hosts are called runtimes). You give the host your JavaScript file; the engine inside it runs the code; and everything that touches the outside world, such as the page, files, the network, and timers, comes from the host.
The browser is the host most people meet first. You open a page, and the browser runs its JavaScript. Somewhere inside the browser is the part that does the running, the engine, and in Chrome that's V8: Chrome hands V8 your code and supplies the page, the network, and timers. Firefox does the same with its engine, SpiderMonkey; and Safari with JavaScriptCore. If you read Write It Like C, that post zoomed in on one engine, V8. Here, we'll zoom out.
Browsers are just one kind of host among many. A runtime such as Node.js supplies files, the network, and modules. A shell, such as the one MicroQuickJS comes with, gives you a small command line. A device SDK (software development kit) such as the Moddable SDK supplies hardware, networking, and graphics. And a compiler such as scriptc is the exception: what it produces is a program that runs with no engine in it.
Engine and runtime
That's the split behind two words you'll see everywhere:
- Engine: the part that executes JavaScript. Give it source code and it runs it, but on its own it has no files, no network, and no event loop. V8, SpiderMonkey, and JavaScriptCore are the engines in Chrome, Firefox, and Safari. Smaller engines exist too: QuickJS, which Fabrice Bellard describes as small and embeddable; and QuickJS-ng, which describes itself the same way.12
- Runtime: an engine plus the things a program needs to talk to the outside world (files, network, modules, timers, and an event loop), packaged as something you run programs with. Node.js, Deno, and Bun are runtimes.
| Layer | What it is | Examples |
|---|---|---|
| Specification | ECMA-262, written by TC39 and published by Ecma International each year; test262 checks engines against it | ECMAScript 2026 |
| Runtime (host) | Embeds an engine and adds files, network, modules, and an event loop; or, in a browser, the page | Node.js, Deno, Bun, a browser |
| Engine | Runs the JavaScript | V8, QuickJS, JavaScriptCore |
The specification's own word for a runtime is host, and MDN's "JavaScript execution model" page says host environment: the part that provides the "environment-specific mechanisms" an engine needs "to interact with the outside world."13 A browser is a host too, even if nobody calls Chrome a "runtime." Every runtime is a host; not every host gets called a runtime.
So when someone says "JavaScript can't do X," they usually mean the host they're using doesn't offer X.
Inside the engine, here's the usual shape, as a general picture that doesn't apply everywhere. A parser turns your JavaScript source into an abstract syntax tree (AST), a tree that represents the structure of the program. The engine compiles the AST to bytecode, and an interpreter runs the bytecode. Only frequently run ("hot") code goes further: a just-in-time (JIT) compiler turns its bytecode into machine code. The parser, interpreter, and JIT compiler are parts of the engine; the AST, bytecode, and machine code are what your code becomes along the way.
Engines vary. Some skip steps: QuickJS goes straight to bytecode with no AST, and Elk interprets source directly.14 Some tools compile ahead of time instead, and leave no engine at run time at all.
That's as deep as this post goes; Write It Like C walks through how V8 does it.
Two more kinds of project show up on engine lists, and it helps to know them on sight:
- Parser: turns source code into a syntax tree and stops there. Nothing is executed. Acorn and Babel's parser are parsers; tools that rewrite, lint, or bundle your code use them.
- Binding: glue that lets another language drive an existing engine. v8go runs JavaScript from Go by embedding V8. A binding isn't a new engine, so code run through v8go is running on V8.
And some projects use more than one of these labels about themselves. GraalJS calls itself "a JavaScript engine" and, a sentence later, "an ECMAScript-compliant runtime." Porffor's README uses "compiler," "engine," and "runtime" for one project.15 Neither is wrong. The useful test is what a project provides, not what it calls itself.
Runtimes: where they run and what they're for
Runtimes are the part most developers choose between, and they differ in two ways: where they run, and what they're for.
- Node.js is the runtime most people mean by "JavaScript outside the browser." It describes itself as "an open-source, cross-platform JavaScript runtime environment,"16 and it's built on Google's V8.17
- Deno describes itself as "a JavaScript, TypeScript, and WebAssembly runtime with secure defaults," also built on V8.18
- Bun leads with "an all-in-one toolkit for JavaScript and TypeScript apps." At its core is a runtime "designed as a drop-in replacement for Node.js" and "powered by JavaScriptCore under the hood."19 Same job as Node.js, different engine.
- The Moddable SDK is "development tools and runtime software to create applications for microcontrollers," built around the XS engine, with support for "networking, sensors, visually rich touch displays" and more.20
Because runtimes supply the host APIs, most of the incompatibility you'll meet lives there: code that reads a file under Node.js won't run in a browser, and the engine has nothing to do with it. ECMA-262 leaves those APIs to the host.21
The JavaScript engine zoo
Put all of that together and you get a zoo: more JavaScript engines and runtimes than most developers ever hear of, many of them in active use somewhere. People call it a zoo because that's what it looks like from outside: dozens of species, all recognizably JavaScript, each adapted to its own habitat.
There are two reasons the zoo exists. One is the history above: since no engine is the language, anyone can build one, and the specification and test262 tell them how close they've come. The other is what each project is for, and that's where the variety comes from. Here are a few, grouped by why they exist. The JavaScript engines zoo has the rest.
Four of the ways they differ:
- How much machine it expects
- How much of the language it takes on
- What it's written in, and what it lives inside
- When it compiles
How much machine it expects
A browser engine expects far more memory, and time to warm up. A microcontroller has kilobytes, and an app opening a screen has no time to spare.
- MicroQuickJS, by Fabrice Bellard and Charlie Gordon, is "a JavaScript engine targeted at embedded systems" that runs in "as little as 10 kB of RAM."22
- Hermes is "a JavaScript engine built for fast start-up and low memory use," created for React Native.23
How much of the language it takes on
The browser engines implement essentially all of ECMA-262, and new editions as they come. Further down the zoo, engines choose.
-
A subset. Elk implements "a small but usable subset of ES6" (ECMAScript 2015), and says what that means in its feature list: "Strings are binary data chunks, not Unicode strings:
'Київ'.length === 8."24 A conforming engine returns4. Elk counts bytes. That isn't a bug anyone caught; it's a design decision the project declared, about what a string even is. Elk also "does not even have a standard library": anything beyond the core language is "imported from C/C++ firmware" by the program that embeds it. - The document, as written. engine262 is "An implementation of ECMA-262 in JavaScript," and lists "100% Spec Compliance" first among its goals.25 It follows the specification step by step, which makes it useful for checking what the document actually says.
Subsets are older than any of these. Around 2001 Ecma even approved a "Compact Profile" of the third edition, ECMA-327, which let implementations for resource-constrained environments leave out with, eval, and the Function constructor and still conform to the profile. It was withdrawn in 2015, and Wirfs-Brock and Eich's comment on it is a fair summary of this whole axis: "If an implementation for such environments needs to exclude certain features, they simply do so."26
What it's written in, and what it lives inside
An application written in Rust, Go, or Java that wants to run user scripts needs an engine it can link into its own process. So there are engines written in those languages. Boa, in Rust, "can be embedded in Rust projects fairly easily," in its own words; goja is written in Go; and with GraalJS, "you can easily embed JavaScript into a Java application."27 engine262, from the previous axis, is written in JavaScript: a JavaScript engine running inside another JavaScript engine.
One word to watch here: embeddable (made to sit inside another program, like Boa or goja) isn't the same as embedded (built for embedded hardware, like MicroQuickJS). Some engines are both, which is why the two get lumped together.
When it compiles
The typical engine reads your code and runs it, and engines differ in when the heavy translation happens.
- While the program runs. V8 starts by interpreting bytecode and compiles the parts that run often into machine code, just in time. Write It Like C is the long version.
- Before the program ships. scriptc is an ahead-of-time compiler: it turns JavaScript into a native program, and nothing reads JavaScript at run time. In its own words, "A compiled program embeds no JavaScript engine, so it cannot run JavaScript source at runtime."28
- Some of each. Hermes' "whole design centers on compiling JavaScript ahead of time": apps ship "compact bytecode," and the engine's interpreter runs it.29
The axes don't line up
It's tempting to read these four as one scale, with big, complete engines at one end and small, partial ones at the other. They don't work that way. QuickJS-ng is small and embeddable and still covers most of the language.30 And none of them has a better end: a subset is the right answer for a device with 10 kB of RAM.
What an engine says about itself
If anyone can build an engine, how do you know what you're getting? Mostly, you read what the engine declares. Some publish a list of what they skip or change, and it's worth reading as a statement with a method behind it, not as a ranking.
-
Hermes, React Native's default engine, keeps a document of its "deliberate differences" from the specification, each with its motivation.31 Most are corners of loose (non-strict) mode, each "a very rare case." One entry isn't a departure at all:
localeCompareignores the locale you pass it, and the document says plainly that "ECMA-262 permits this." Its motivation there is size: the collation table it uses instead "is about 110 KB, needs no system library." - XS, the engine in the Moddable SDK, publishes its own conformance document. It runs test262 through its own harness and says what it skips and why: the internationalization tests, because "XS does not implement ECMA-402, the Internationalization API Specification"; and the tests for features only web browsers need, because "No XS hosts are web browsers."32
- scriptc publishes a limitations page instead of a score. It "checks programs against the es2025 standard library" and lists what doesn't compile.28
A project's own description tells you what it's for; independent checks show how that holds up. test262.fyi runs the official suite against many engines every day.33 And for speed, there's a JavaScript engine benchmark.34
One more thing worth knowing: conforming and agreeing aren't the same promise. The specification allows some answers to differ, so two engines can both conform and still disagree.35
None of this makes one engine the real JavaScript and the rest copies. They're all implementations of the same specification, each built for its own place. And yet, give them the same maths and they won't all hand back the same answer, even though each one conforms. In the next post, we'll explore in more detail how the conform-but-still-disagree paradox shakes out with regard to maths.
Mara Averick is a developer advocate at Quansight and contributor experience lead for stdlib.
stdlib is an open source software project dedicated to providing a comprehensive suite of robust, high-performance libraries to accelerate your project's development and give you peace of mind knowing that you're depending on expertly crafted, high-quality software.
If you've enjoyed this post, give us a star 🌟 on GitHub and consider supporting the project. Your contributions and continued support help ensure the project's long-term success and are greatly appreciated!
Acknowledgments
This work was supported in part by the National Science Foundation under Award No. 2449410.
Disclaimer: Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.
-
The JavaScript engines zoo, from
ivankra/javascript-zooata17d4e0. Itsengines/folder has 144 entries at that commit (counted 2026-10-30), some of them runtimes or variants rather than distinct engines. ↩ -
Ecma International, ECMA-262, 17th edition: ECMAScript 2026 Language Specification, June 2026 (PDF); also in HTML. The working draft of the next edition is at tc39.es/ecma262. ↩
-
Counted 6 November 2026 at
63d939f, onmain: 53,790 test files undertest/, not counting*_FIXTURE.jshelpers. That includes 3,393 intest/intl402, for the internationalization API, which has a specification of its own; and 1,487 intest/staging, not yet moved into the main tree; without those two, it's 48,910. These are files, not runs: unless a test is flagged otherwise, a runner executes it twice, in strict and non-strict mode. ↩ -
Allen Wirfs-Brock and Brendan Eich, "JavaScript: The First 20 Years," Proceedings of the ACM on Programming Languages 4 (HOPL), article 77, 2020, doi:10.1145/3386327. The quotation, and the 1996 and 1997 dates, are from page 77:3. The 1995–96 events are in its appendix E.1, page 136 of the authors' corrected version. ↩
-
ESNext is informal, not an Ecma name. It means the next version as of reading: the ES2027 draft, at tc39.es/ecma262, which holds the finished proposals TC39 lists as "(or soon will be) included in the latest draft" (
finished-proposals.mdat07002d4), both read 15 November 2026; and, for some, proposals still in progress too. The ECMAScript Next compatibility table uses it that way, for "proposals which have not yet been included in the current ECMAScript standard, but are at one of the maturity stages of the TC39 process" (source at0ad4479, read 16 November 2026). ↩ -
Deno, "A brief history of JavaScript", 22 May 2025, read 15 November 2026 (archived). A few of its dates differ from Ecma's and Wirfs-Brock and Eich's; the timeline uses theirs. ↩
-
The Rust project's announcement of the adoption, 26 March 2025, by its Spec Team, which says the project is "dropping the expansion and just calling it the FLS." The quotations are from the FLS's §1.1, Scope, built from commit
460668a, which describes rustc version 1.99.0; the FLS marks that section as informational. Both read 16 November 2026. ↩ -
C: ISO/IEC 9899, per WG14, the C standards committee. SQL: ISO/IEC 9075 is a multi-part standard, and Part 2, Foundation is the core language; both read 2 November 2026. On how databases differ, PostgreSQL's own SQL Conformance appendix, for PostgreSQL 18, says it "supports most of the major features of SQL:2023," and that "no current version of any database management system claims full conformance to Core SQL:2023." Read 16 November 2026. ↩
-
Perl's own policy document asks for its documentation "to accurately reflect the current implementation." The capitalization is perlfaq1's: "'Perl' is the name of the language," and perl is the interpreter. The truism is from the documentation of PPI, a module for parsing Perl source as documents (version 1.291, "Background"). It credits Tom Christiansen with introducing "Nothing but perl can parse Perl" to the Perl community, and gives the shorter form as the way "it is more often stated now," with no one named for it. All read 16 November 2026. ↩
-
importis language syntax, but finding and loading the file it names is a host-defined operation: ECMA-262, 17th edition, §16.2.1.10, HostLoadImportedModule (PDF, page 432). ↩ -
MDN contributors, "Language and runtime", in "JavaScript language overview," MDN Web Docs, read 4 November 2026 through its source at
a4fcf79(archived). The core specification "focuses on pure computational logic. It doesn't deal with any input/output," and without runtime-level APIs, "most notably"console.log(), a program's behavior "is entirely unobservable." ECMA-262 says much the same in its own overview, a non-normative section: "ECMAScript as defined here is not intended to be computationally self-sufficient; indeed, there are no provisions in this specification for input of external data or output of computed results" (ECMA-262, 17th edition, §4 Overview; PDF, page 26). ↩ -
QuickJS: Fabrice Bellard's page for it, read 16 November 2026. QuickJS-ng: "a small and embeddable JavaScript engine," in its README at
7a23d8e. ↩ -
MDN contributors, "JavaScript execution model", section "The engine and the host," MDN Web Docs. Read 16 November 2026 through its source,
mdn/contentat9de1491. ↩ -
QuickJS:
doc/quickjs.texiat7d1c13c. Elk: "No bytecode. Interprets JS code directly," in its README at71a86fa. ↩ -
GraalJS: "a JavaScript engine implemented in Java on top of GraalVM," and "an ECMAScript-compliant runtime to execute JavaScript and Node.js applications," in its README at
7cb99ef. Porffor, where AOT is short for ahead-of-time: "An ahead-of-time JavaScript compiler" and "a 100% AOT compiled JS engine/runtime," in its README at0c135ce. ↩ -
Node.js, README at
502c117, read 29 October 2026. ↩ -
MDN contributors, "JavaScript implementations", in "JavaScript technologies overview," MDN Web Docs, which lists Node.js among V8's non-browser uses; read 16 November 2026 through its source at
2a563c9. ↩ -
Deno, README at
e7b39eb. ↩ -
Bun, README at
da867c6. ↩ -
The Moddable SDK's README at
80076c4, which also calls XS "The XS JavaScript engine at the center of the Moddable SDK"; and moddable.com, read 29 October 2026, for the list of what it supports. ↩ -
Two newer Ecma standards define APIs that a host provides. ECMA-419, from TC53, is the "ECMAScript® Embedded Systems API Specification," standard APIs for embedded hardware, and Moddable says its "migration to ECMA-419 is nearly complete" (moddable.com, read 29 October 2026). ECMA-429, from TC55 ("WinterTC"), is a "Minimum common web API" for server runtimes. ↩
-
MicroQuickJS, README at
6d4d7eb. ↩ -
Hermes, README on
static_hatc319a1a, committed 14 November 2026, read 16 November 2026: "Hermes was created for React Native, where it is the default engine." ↩ -
Elk, README at
71a86fa. A conforming engine's.lengthcounts UTF-16 code units; each of the four Cyrillic letters in Київ is one unit, so the answer is4, where Elk's eight is the string's UTF-8 bytes. ↩ -
engine262, README at
d553e7b. "100% Spec Compliance" is a stated goal, not a score. ↩ -
Wirfs-Brock and Eich, "JavaScript: The First 20 Years," page 77:58. ↩
-
Boa's about page, read 25 October 2026. GraalJS, README at
7cb99ef. ↩ -
scriptc, limitations, read 15 November 2026. ↩
-
Hermes, README on
static_hatc319a1a, "Ways to run code": "Code is compiled ahead of time, the bytecode file is memory-mapped, and the interpreter runs it." Apps can also ship native code, and source still runs during development. ↩ -
By the JavaScript engines zoo's own feature tests, not test262: its entry for QuickJS-ng,
engines/quickjs-ngata17d4e0, read 30 October 2026. ↩ -
Hermes, "Incompatibilities With The JavaScript Spec", on
static_hat85480fe, read 16 November 2026. It names Static Hermes, which the README calls "the code name for an umbrella project, developed on thestatic_hbranch." ↩ -
Moddable, "XS Conformance", at
80076c4, revised 31 January 2026. The skipped web-browser tests are test262's Annex B tests. ↩ -
test262.fyi, which describes itself as a "daily runner of test262 for many engines," read 16 November 2026. Its results change every day. ↩
-
ahaoboy,
js-engine-benchmarkat5e1b678, whose README says it's a fork of the V8 benchmark suite (v7) in Mozilla's arewefastyet, atd2ddc6c, its last change to that folder. Read 16 November 2026. ↩ -
ECMA-262, 17th edition, §4.2, Hosts and Implementations (PDF), which defines an implementation-approximated facility and says "conforming implementations are free to choose any behaviour within the constraints put forth by this specification." Read 16 November 2026. ↩






Top comments (0)