A short history of JavaScript

JavaScript is unusual among mainstream languages: it was designed under deadline pressure, standardized late, fought over as a trademark, and still ships in every browser while also powering servers and build tools. The dates matter, but the pattern matters more — host environments and committee process shaped the language as much as any single feature list.

Netscape and the first name

In 1995 Netscape needed a language for dynamic behavior in Navigator 2. Brendan Eich implemented a prototype in about ten days. It was first called Mocha, then LiveScript, then JavaScript — a marketing name tied to Java, though the two languages share little beyond C-like syntax.

Microsoft shipped JScript for Internet Explorer 3 in 1996. Two incompatible dialects in the two dominant browsers made cross-browser pages painful. Standardization became a business necessity, not an academic exercise.

ECMAScript and the early editions

Netscape submitted the language to Ecma International. The first edition of the standard, ECMA-262, appeared in 1997 under the name ECMAScript so Sun could keep the JavaScript trademark. Edition 3 (ES3), published in 1999, is the baseline many older tutorials still mean when they say “JavaScript”: try/catch, regular expressions, better Unicode support, and the object model most of the web grew up with.

Edition 4 was abandoned after years of disagreement. Mozilla, Microsoft, and others could not agree on how far to change the language. That failure delayed large syntactic updates for a decade and pushed innovation into libraries and host APIs instead.

The Ajax era and the engine race

Around 2005, Ajax — using XMLHttpRequest to update part of a page without a full reload — made heavy client-side logic normal. jQuery (2006) papered over DOM differences; frameworks followed. Applications needed faster execution, not just more APIs.

Google open-sourced V8 in 2008 for Chrome. Competing engines (SpiderMonkey in Firefox, JavaScriptCore in Safari, later Edge on Chromium with V8) invested in JIT compilation. JavaScript was no longer a “toy” language in practice; it was a performance target.

ES5, strict mode, and Node.js

ES5 (2009) added JSON, array methods such as forEach and map, getters and setters, and strict mode ("use strict"), which rejects some silent errors from ES3. It was the last edition before the modern yearly cadence, and it landed while engines were still racing on speed.

Ryan Dahl released Node.js in 2009, binding V8 to libuv and file/network APIs. The same language ran in the browser and on the server; npm (2010) became the default package registry. Server-side JavaScript stopped being a novelty.

ES2015 and the yearly release model

After ES4 collapsed, TC39 adopted a yearly release model. ES2015 (also ES6) shipped classes (syntactic sugar over prototypes), let and const, arrow functions, modules (import/export), promises, iterators, generators, Map/Set, template literals, and destructuring — the largest single edition since ES3.

Subsequent editions stayed smaller: ES2016 (Array.prototype.includes, exponentiation operator), ES2017 (async/await, Object.entries), and so on through ES2024 and ES2025 (iterator helpers, Set methods, import attributes, and more). The edition year in the name is the publication year of the standard, not necessarily when engines finished shipping every feature.

TypeScript, Babel, and “JavaScript++”

TypeScript (2012) adds static types and compiles to JavaScript. It did not replace the standard; it sits beside it and tracks TC39 proposals. Babel (2014) transpiles new syntax for older runtimes. Together they decoupled authoring from deployment targets: you can write tomorrow’s syntax while browsers catch up.

Deno, Bun, and WinterTC

Deno (2020) reimagined a secure TypeScript-first runtime with explicit permissions. Bun (2022) marketed an all-in-one fast runtime with bundler and test runner. Both still execute ECMAScript plus host APIs, like Node.

WinterTC (Web-interoperable Runtimes Community Group) documents behavior shared across browser, Node, Deno, and workers — fetch, streams, timers — so “JavaScript on the server” is less ad hoc than in Node’s early years.

Trademark and naming

Oracle inherited the JavaScript trademark from Sun. The JavaScript name remains a trademark; ECMAScript is the language specification name. Legal disputes (including Oracle vs Google over Android/Java APIs, with indirect effects on the ecosystem) kept lawyers involved, but day-to-day developers work against ECMA-262 and MDN, not trademark filings.

Milestones at a glance

What this history explains for developers

If you come from Java or Python, three facts explain many “why is JS like this?” moments:

The standard lagged the web. DOM APIs and async patterns lived in browsers before they were fully reflected in ECMAScript. Hosts still add APIs faster than TC39 adds language features.

Compatibility is non-negotiable. New features are usually additive. Breaking old pages is not an option, so quirks from ES3 persist alongside modern syntax.

Engines lead adoption. A proposal at stage 4 means the spec is settled; shipping in all browsers you care about is a separate timeline. Tooling (Babel, TypeScript) bridges the gap.

Next: How ECMAScript is standardized.