A Brief History of JavaScript

Netscape releases Netscape Navigator 1.0

Netscape Navigator 1.0 was a watershed moment for the web. It quickly became the most popular web browser, as it was faster and easier to use than Mosaic (a web browser released in 1993). It had a slick graphical UI, unlike many of the earlier text-based browsers. Also it supported emerging standards like HTML 2.0, and eventually... JavaScript.

Brendan Eich creates the very first version of JavaScript

Netscape wanted to add interactivity to the early web, which at the time was mostly written in HTML. Around the same time, Sun Microsystems launched Java, and as part of that launch, Netscape licensed Java for use in the browser. But Java was a little too complicated for web designers.

Netscape asked Brendan Eich to develop a scripting language that looks like Java, but be object oriented rather than class based. And in ten short days, the language that powers most of the internet today was born. They arrived at the name “JavaScript” for marketing reasons, as Java, at the time, was the hot new programming language, so the name exploited that popularity.

Netscape and Sun announce JavaScript, the open, cross-platform object-oriented scripting language for enterprise networks and the internet

JavaScript was introduced as an easy-to-use, lightweight scripting language for adding interactivity to HTML. In this announcement, Netscape and Sun laid out their vision for the new web: Java objects being served to the client, where JavaScript scripts can modify them. Also notable is the industry support from 28 technology companies, ranging from America Online to Toshiba Corporation.

Microsoft introduces JScript in Internet Explorer 3 to compete with Netscape Navigator

JScript, named to avoid the copyrighted word “Java”, was an open implementation of JavaScript molded to the Windows ecosystem. Unlike Netscape's JavaScript, JScript could interact with Window's ActiveXObject, allowing developers to connect from Internet Explorer to an Excel spreadsheet for instance.

var ExcelSheet;
ExcelSheet = new ActiveXObject(“Excel.Sheet”);
// Make Excel visible through the Application object.
ExcelSheet.Application.Visible = true;
// Place some text in the first cell of the sheet.
ExcelSheet.ActiveSheet.Cells(1,1).Value = “This is column A, row 1”;
// Save the sheet.
ExcelSheet.SaveAs(“C:TEST.XLS”);
// Close Excel with the Quit method on the Application object.
ExcelSheet.Application.Quit();
// Release the object variable.
ExcelSheet = “”;

Netscape Navigator 2.0 is released with JavaScript 1.0

This is JavaScript's debut, landing in millions of homes with Netscape Navigator 2.0. With JavaScript 1.0 came another key innovation that became a fundamental model of the web — the Document Object Model (DOM).

Netscape submits JavaScript to ECMA International

To avoid a fractured browser ecosystem, with JavaScript and Microsoft's JScript, Netscape submitted JavaScript to ECMA International, aiming to create a vendor-neutral standardized language that everyone can use. The standard spec was called ECMA-262 and the language “ECMAScript” (not named JavaScript due to trademark issues), of which JavaScript and JScript became dialects. Additionally, a technical committee named TC39 was formed, consisting of representatives from Netscape, Microsoft, Sun Microsystems, and more, to govern the evolution of ECMAScript.

Amid declining market share, Netscape open sources Navigator, leading to the creation of The Mozilla Project

Since Microsoft bundled Internet Explorer with Windows, Netscape Navigator saw a rapid decline in market share. In a bold effort to save the company and compete with Microsoft, Netscape open sources its browser code, “Mozilla” (its internal codename, a portmanteau of “Mosaic” and “killer”), to allow the community to contribute to the development of a more advanced and standards-compliant browser. The next day, Jamie Zawinksi of Netscape registered mozilla.org. The Mozilla project created several impactful technologies and products: Firefox, tabbed browsing, browser extensions, and the programming language, Rust.

Official release of the first ECMAScript language specification (ECMAScript 2)

Though no new features were added to the ECMAScript language, it ensured the spec was clean, consistent, and standardized. This set the groundwork for all future editions.

Microsoft releases Internet Explorer 5, which uses more proprietary technology than before.

More importantly, Microsoft introduces XMLHttpRequest — the first practical way to send HTTP requests via JavaScript:

// How to send an HTTP request in IE5.

<script type="text/javascript">
  function makeRequest() {
    // Create the ActiveXObject (specific to IE5/IE6)
    var xhr = new ActiveXObject("Microsoft.XMLHTTP");

    // Open a GET request (async = true)
    xhr.open("GET", "https://example.com/data.txt", true);

    // Define a callback to run when the response is ready
    xhr.onreadystatechange = function() {
      if (xhr.readyState === 4 && xhr.status === 200) {
        alert("Response received: " + xhr.responseText);
      }
    };

    // Send the request
    xhr.send();
  }
</script>

<button onclick="makeRequest()">Send HTTP Request</button>

JSDoc debuts

JSDoc, loosely based off Javadoc for Java, introduced a formal structured way to document JavaScript. This brought professionalism to the language, laid the groundwork for IDE support, and enabled documentation generation (it powers deno doc as well as the docs generation for modules on jsr.io).

/**
 * Adds two numbers together and returns the result.
 * @param {number} value1 The first value
 * @param {number} value2 The second value
 */
function addNumbers(value1, value2) {
  return value1 + value2;
}

ECMAScript 3 is released with do-while, regex, new string methods (concat, match, replace, slice, split), exception handling, and more

ECMAScript 3 was an important early milestone in JavaScript, as it transformed it from a toy scripting language into a serious programming tool. It would become the baseline language for browser scripting for over a decade, and widely considered as the version of JavaScript that defined the language for the web.

The first JSON message is sent

And it looks something like this:

<html><head><script>
    document.domain = 'fudco';
    parent.session.receive(
        { to: "session", do: "test",
          text: "Hello world" }
    )
</script></head></html>

JSLint, the “grandfather of all JavaScript syntax checkers” is introduced

JSLint, created by Douglas Crockford, was the first major static code analysis tool for JavaScript. At the time, JavaScript was widely used but poorly understood, and written without discipline. JSLint sought to level up the code quality. The strong opinions enforced by JSLint helped form Crockford's book, “JavaScript, the Good Parts”.

Mozilla releases Phoenix 0.1, precursor to Firefox, to compete with Internet Explorer

Fed up with how slow and bloated the Mozilla Application Suite was, a small team built a minimalist stripped down version of a web browser called Phoenix (to signify the rebirth of the browser from the ashes of Netscape and Mozilla Suite). At the time, Internet Explorer had 90% of market share, and innovation stagnated. Phoenix offered something new to internet users: speed, simple UI, tabbed browsing, and pop-up blockers. This marked the rebirth of user-focused, open-source browsers, became the foundation of Firefox, and broke Microsoft's monopoly on the browser market.

Apple introduces Safari and WebKit

Apple CEO Steve Jobs announces Safari, “a turbo browser for Mac OS X”. Most importantly, it ended Apple's dependence on Microsoft, as before Mac users relied on Internet Explorer for Mac. Additionally, this paved the way for Apple's Mobile Safari a few years later with the iPhone. It is based on WebKit, an internal fork of the KHTML browser engine.

A beta version of Gmail is released, which uses a new asynchronous JavaScript protocol, “AJAX”

The launch of Gmail was a turning point in web development. AJAX allowed Gmail to offer a highly responsive, interactive user experience that was unprecedented for a web site at the time, ushering a new Web 2.0 era of web applications.

Jesse James Garrett coins “AJAX” in his white paper, “Ajax: A New Approach to Web Applications”

Ajax, short for asynchronous JavaScript and XML, is a set of client-side techniques to create web apps that can send and receive data from a server asynchronously without needing a page reload. This unlocked a whole new class of web apps, as well as frameworks, that can deliver a rich and seamless user experience.

<script type="text/javascript">
  function createXHR() {
    if (window.XMLHttpRequest) {
      // Modern browsers (Mozilla, Safari, IE7+)
      return new XMLHttpRequest();
    } else if (window.ActiveXObject) {
      // Older versions of IE (IE5, IE6)
      try {
        return new ActiveXObject("Msxml2.XMLHTTP");
      } catch (e) {
        try {
          return new ActiveXObject("Microsoft.XMLHTTP");
        } catch (e) {
          alert("AJAX not supported in your browser.");
          return null;
        }
      }
    }
    return null;
  }

  function loadData() {
    var xhr = createXHR();
    if (!xhr) return;

    xhr.onreadystatechange = function() {
      if (xhr.readyState === 4) {
        if (xhr.status === 200) {
          document.getElementById("result").innerHTML = xhr.responseText;
        } else {
          alert("Request failed: " + xhr.status);
        }
      }
    };

    xhr.open("GET", "/messages/latest", true); // Simulated Gmail-style endpoint
    xhr.send(null);
  }
</script>

<button onclick="loadData()">Load Latest Message</button>
<div id="result">Waiting for response...</div>

The Mozilla Corporation launches DevMo By Mozilla, which becomes MDN

Mozilla launches DevMo By Mozilla, which later became known as MDN (Mozilla Developer Network). MDN provided an accurate, vendor-neutral, and standards-based documentation, and functioned as a central place for learning web standards. This came at a critical time when browser incompatibility was a major pain point, and documentation was fragmented, outdated, and inconsistent. MDN quickly became the go-to resource for web developers, and set a new standard for developer documentation.

John Resig creates first commit to a project named jQuery

jQuery, a JavaScript library designed to simplify HTML DOM tree traversal, event handling, Ajax, and more, was created to address frustrating issues related to cross-browser compatibility. It also provides a well documented terse API that sets a new standard for the developer experience and remains the most widely used JavaScript library in terms of actual page loads.

<script src="https://code.jquery.com/jquery-1.0.0.min.js"></script>
<script type="text/javascript">
  function sendRequest() {
    $.ajax({
        url: "https://example.com/data",
        type: 'GET',
				success: function(res) {
					document.getElementById("result").innerHTML = res;
        },
        error: function(xhr, status, error) {
          alsert("Request failed: " + status);
        }
    });
  }
</script>

<button onclick="sendRequest()">Fetch data</button>
<div id="result">Waiting for response...</div>

The first Apple iPhone is released with its mobile safari not supporting Flash

The exclusion of Flash was a deliberate and controversial decision. At the time, Flash was responsible for 90% of interactive multimedia. However, Steve Jobs was against Flash, due to its high resource needs, prone to crashing, and proprietary nature. Developers took this as a sign that the future of mobile web content would not rely on Flash.

Netscape Navigator is sunset, marking the end of the “First Browser War”

AOL officially discontinues Netscape Navigator, which was a dominant browser in the 90's with over 90% market share at its peak, marking the end of an era for one of the most influential web browsers of the early internet. It lost ground to Internet Explorer, because Microsoft bundled with Windows, which led to a landmark anti-trust lawsuit against Microsoft that reshaped tech regulations.

Douglas Crockford publishes “JavaScript: The Good Parts”

This book reframed JavaScript as a serious language when previously it had been mocked for poor design and confusing behavior.

Google releases the Chrome browser, the fastest web browser at the time, and with it, the V8 engine.

At the time, browsers like Internet Explorer, Firefox, and Safari were relatively slow, with limited focus on JavaScript execution speed. Chrome was designed with a focus on speed, using the new V8 JavaScript engine. V8 was innovative in that it compiled JavaScript into native machine code before execution, implemented just-in-time compilation, and managed memory more efficiently through garbage collection. Google would soon open source V8, allowing developers to build on top of it, most notably the Node.js project.

A specification for sharing JavaScript code, CommonJS (originally named ServerJS), is created

At this point, JavaScript began expanding beyond the browser to the server. Bigger projects were being built and JavaScript needed a better way to handle a lot of source code. It needed modularization. For more information on the history of CommonJS and how we got to where we are today, check out this blog post.

Ryan Dahl begins work on Node.js

Node.js, a cross-platform, open source JavaScript runtime environment, allowed the execution of JavaScript outside a web browser. With the introduction of Node.js, developers were able to create web servers and effectively full stack applications entirely in Javascript. Today, Node is used by ~3.5% of all websites (with known servers) and continues to be a predominant technology for building for the web.


Ryan introduces Node.js in a talk a few years later. For an in-depth look at the Node.js project, check out this one hour-long documentary.

Oracle acquires Sun Microsystems, and with it, the JavaScript trademark

Oracle bolsters its position in the enterprise technology market with the purchase of Sun Microsystems and its ownership of Java. As part of the deal, Oracle acquires the trademark for JavaScript, creating confusion for the future of the language. Read more about our current effort to #FreeJavaScript from Oracle about the trademark.

The first commit on Express.js is created

Express.js, a minimal, flexible, extensible web framework for Node.js, is one of the most widely used frameworks in the ecosystem. It introduces a modular middleware architecture with a focus on building RESTful APIs. It's influence on the ecosystem is unparalleled, inspiring frameworks like Koa, Nest, Fastify, and more. Though there was a period of time when the Express project did not receive active commits, today, it is on version 5, and is actively maintained.

ECMAScript 5 adds a strict mode, getters and setters, new array methods, JSON support, string.trim(), trailing commas for object literals

ECMAScript 5 marked the first major update to the language in 10 years, and introduced features that made JavaScript more powerful, secure, and maintainable.

The first commit to a project named CoffeeScript is created

CoffeeScript was quickly adopted due to cleaner syntax (less boilerplate), arrow functions (before arrow functions), destructuring before ES6, and other quality of life improvements.

npm 1.0 is released

A registry for Node and JavaScript, npm, forever changes the way that JavaScript is shared. Now, it is the biggest open source registry in the world, with over 3 million packages.

WebStorm 1.0, a new JavaScript IDE by JetBrains, is released

Prior to WebStorm, text editors provided minimal support for JavaScript. WebStorm was the first dedicated JavaScript IDE that offered advance features like code analysis, error detection, code completion for JS/HTML/CSS, and debugging tools tailored to JavaScript.

AngularJS and Backbone.js are released

As JavaScript improves and developers are searching for newer, faster, easier ways to build more complex servers and applications, two full stack frameworks — AngularJS and Backbone — are released. They become popular for different reasons: Angular was declarative and opinionated; while Backbone was imperative and minimal. This also loosely marks the beginning of the modern Single Page Application (”SPA”) and “Framework churn”, a term that defines the manic emergence and retirement of several JavaScript frameworks in this era.

Microsoft and Joyent ported Node.js to Windows

In 2011, Ryan Dahl of Joyent and Bert Belder (current Deno co-founder/CTO) ported Node.js to Windows, a significant milestone that expanded Node.js’s reach beyond Unix-based systems. One result from this effort was libuv, a library that offers a unified interface for asynchronous networking on Linus, OSX, and Windows. This not only accelerated Node.js’s growth but also set the stage for Microsoft’s broader open-source strategy, ultimately transforming its developer ecosystem and paving the way for future initiatives like TypeScript, VS Code, and Azure Cloud Integration.

Webpack, a module bundler, is introduced

Webpack allowed developers to import anything to the client-side and eventually became the core build system behind React, Angular, Vue, and more. It laid the groundwork for Rollup, Parcel, Vite, and esbuild.

Microsoft makes TypeScript 0.8 available for the public

In 2010, Anders Heljsberg (who also created C# and Turbo Pascal) began developing a static typed superset of JavaScript, named TypeScript. The goal of this project was to make it easier to write and maintain JavaScript at scale. In 2012, Microsoft makes it available for the public. TypeScript paved the way for enterprise-grade development in the JavaScript ecosystem, influenced the design of ECMAScript itself, and changed how large applications are built with JavaScript.

function add(x: number, y: number): number {
  return x + y;
}

The first commit to Atom Shell (later renamed to Electron) was created

Atom Shell (renamed to Electron in 2015) lowered the barrier to building cross-platform desktop applications by using web technologies like HTML, CSS, JavaScript. It uses Node.js and Chromium, so developers could access the filesystem, network, and native OS APIs. Originally built to power GitHub's Atom text editor, which launched in public beta in April 2014, Atom Shell was used by some high profile early adopters, such as Slack. This framework played a pivotal role in ushering in an era where web technologies could be used to create desktop applications.

Mozilla releases asm.js

asm.js is a strict subset of JavaScript designed to bring near-native performance to the web. Before, JavaScript was not considered suitable for CPU-intensive applications like 3D games and video processing. Developers could convert C/C++ code to asm.js, allowing for existing native applications to run in the browser. This was a huge step forward in the evolution of JavaScript as a serious runtime for computationally expensive applications, and paved the way for WebAssembly a few years later.

(function Module(stdlib, foreign, heap) {
  "use asm";

  function add(x, y) {
    x = x | 0;
    y = y | 0;
    return (x + y) | 0;
  }

  return { add: add };
})(this, {}, new ArrayBuffer(1024));

console.log(Module.add(10, 20)); // Outputs: 30

Valeri Karpov coins the term “MEAN” stack

The MEAN stack represents a full stack JavaScript framework that includes MongoDB, Express.js, AngularJS, and Node.js. This terminology became highly influential in shaping modern JavaScript-based web development.

Facebook releases React

React, created by Jordan Walke, a software engineer at Facebook (now Meta), is a JavaScript library for declaratively building user interfaces. It was first introduced in the Facebook Newsfeed in 2011, and open sourced for the public in May 2013 at JSConf US. React’s component-driven approach for building interfaces solidified declarative UI patterns used in apps today.

Work on ESLint begins

Nicholas C. Zakas, a prominent JavaScript developer and former lead developer of the Yahoo! User Interface Library (YUI), began work on ESLint, a pluggable and configurable linter tool for identifying and fixing problems in JavaScript code. ESLint quickly became a crucial tool for JavaScript developers, addressing limitations in existing linting tools and setting new standards for code quality and consistency.

Gulp is released

Eric Schoffstall releases Gulp.js, a streaming build system for automating tasks in web development. Gulp introduced a new way to handle repetitive tasks like minification, compilation, linting, and testing by using a simple, code-centric approach. It quickly gained popularity as a powerful, code-centric alternative to older task runners like Grunt, which was configuration-heavy, and influenced the evolution of modern build tools.

Vue.js is released

Evan You, a former Google engineer, releases Vue.js, a progressive JavaScript framework for building user interfaces. Unlike other frameworks of its time, Vue.js was designed to be approachable, incrementally adoptable, and highly performant, making it one of the most popular and influential frameworks in the modern JavaScript ecosystem.

Strongloop purchases open source framework Express

StrongLoop (co-founded by Deno co-founder, Bert Belder), a company specializing in enterprise-grade Node.js solutions, acquired the rights to Express.js, with the goal of integrating it into a broader suite of tools focused on APIs and microservices. The community felt that Express's independence would be lost in the acquisition, which led to creating other frameworks such as Koa. Later, IBM acquired StrongLoop in 2015, and in 2019, Express.js joined the OpenJS Foundation, securing its governance and ensuring its long-term sustainability. After 10 years of being at Express 4.x, Express 5 was finally released in October 2024.

The first commit to Babel.js is created

Originally named 6to5, Babel.js is a JavaScript compiler that allows developers to write modern JavaScript and make it backwards-compatible for older browsers and engines. Babel soon established itself as a standard tool in the ecosystem, being integrated into popular frameworks like React, Vue, and Angular, as well as module bundlers like Webpack, Rollup, and Parcel.

Meteor reaches 1.0

Meteor made a splash in web development communities for being a radically simpler way to build real-time, JavaScript-only, full-stack applications. It played a major role in shaping how developers thought about building modern, reactive, real-time web applications. Although Meteor's overall popularity waned as the ecosystem evolved, it's influence can be seen in React, Redux, Firebase, GraphQL, and more.

Facebook launches Flow, a static type checker for JavaScript

Flow is a static type checker for JavaScript that helps developers catch bugs and type errors during development. Facebook developed it as a way to better maintain its massive codebase and improve developer productivity. By the late 2010s, however, TypeScript became the dominant typed JavaScript language, leading to the decline of Flow.

Amazon announces AWS Lambda, powered by Node.js

Amazon Web Services, already a market leader in cloud computing, introduces a new serverless paradigm with Lambda, which allows developers to upload code and run it in response to events without provisioning infrastructure. At launch, Lambda functions only supported JavaScript with Node.js, thanks to Node.js’s event-driven, non-blocking model that fit well with Lambda’s stateless and short-lived execution environment. The arrival of AWS Lambda introduced the concept of Function-as-a-Service and kicked off a serverless computing movement, with Google and Microsoft launching their own versions a year or two later.

Fedor Indutny creates io.js, a fork of Node.js

Node.js, maintained by Joyent at the time, had slow releases and lacked support for modern JavaScript features due to being on an outdated version of V8. Many developers became frustrated that Node.js wasn't evolving fast enough, especially compared to the rapid progress in the browser and frontend world. Thus, the fork io.js was created. The intention is to merge io.js back into Node.js later.

The term “Jamstack” is coined by Matt Biilmann, CEO of Netlify.

Jamstack (”Jam” an acronym for JavaScript, API, and Markup) is a web development architecture pattern for frontend web development that offers better performance, scalability, and developer experience. This marks the start of a new era in modern web development where developers are moving away from SPA-architectures and more towards SSR and SSG.

The Node.js Foundation is introduced.

Under the umbrella of the Linux Foundation, the Node.js Foundation was established to advance the development and adoption of Node.js by resolving project fragmentation. At the time, io.js, a prominent fork of Node.js, was managed by a group of former Node.js contributors seeking faster releases and better governance, which was merged back into Node.js in June 2015. The Node.js foundation had the support of major tech companies, such as IBM, Microsoft, PayPal, Intel, Fidelity, Joyent, and the Linux Foundation.

GraphQL, a query language for APIs, is launched

Facebook began development on GraphQL in 2012 as a data query language that can be used declaratively. GraphQL offered a new way to access and mutate data, with fewer trips to the server and strong typing.

Redux is released

With more and more developers building apps using React, the need for managing state rose. Redux, a predictable state container, was released to help. Now, Redux can be used with a wide variety of JavaScript frameworks.

Web assembly is released

Web assembly aimed to solve the performance limitations of JavaScript in the browser. It enabled high speed execution of code intensive applications, like games, video editing, and more. It also addressed the need for a portable, secure way to run code written in languagse like C/C++ on the web.

Atom, a “hackable” text editor, is released

Atom was one of the first highly extensible desktop editors built entirely on web technologies. It emphasized deep customization, letting developers tweak everything from the UI to the core behavior with packages and themes. Not only did Atom validate Atom Shell (now known as Electron) as a framework for developing cross-platform desktop applications, it shifted how developers thought about text editors from tools to platforms. It inspired a wave of modern, extensible, web-powered tools such as VS Code, which adopted and refined many of Atom's core ideas.





Atom 1.0 was released with this retro announcement video from GitHub.

ECMAScript 6 (ES2015) is released

With the release of ES6, JavaScript finally got many of the features that developers had been asking for, like the fetch API and ESM native module system with import and export.

<script type="text/javascript">
    function getData() {
      fetch("https://api.example.com/data")
        .then(response => {
          if (!response.ok) {
            throw new Error("Network response was not ok: " + response.status);
          }
          return response.text(); // or response.json() for JSON APIs
        })
        .then(data => {
          document.getElementById("result").textContent = data;
        })
        .catch(error => {
          console.error("Fetch error:", error);
          alert("Error fetching data.");
        });
    }
}

<button onclick="getData()">Fetch data</button>
<div id="result">Waiting for response...</div>

Node.js v0.12 and io.js merge to form Node.js v4.0

Node.js v4.0 represents countless hours of work in both the Node.js and the io.js project that is combined in a single codebase. The merger, which brings to close a fractured community in which many npm modules became incompatible with one or the other runtime, also brought a Long-Term support schedule and a new semantic versioning scheme. The success of the merger demonstrated the power of open governance and community collaboration.

Microsoft open sources Edge's Chakra JavaScript engine

Microsoft aimted to attract external contributors and increase adoption beyond their Edge browser by open sourcing Chakra. It attracted significant initial interest from developers, and Microsoft even released a version of Node.js running on Chakra. However, V8 remained the dominant engine, largely due to its massive community and extensive tooling. By 2021, Microsoft announced the deprecation of Chakra, ceasing active development, as Microsoft began transitioning to the Chromium-based Edge that relied on the V8 engine.

Azer Koculu removes Leftpad from npm, inadvertently leading to a supply chain attack on the order of millions of users impacted

Commonly known as the “npm Leftpad incident”, Azer removes left-pad from npm after a dispute with Kik Messenger. As a result, thousands of projects using left-pad as a dependency, including React and Babel, were unable to be built or installed. This created a huge disruption across major technology corporations, such as Meta, Netflix, Spotify, and highlighted the staggering magnitude that a supply chain vulnerability might have in the JavaScript ecosystem. Since then, npm changed its policy to limit a users’ ability to remove their package.

Microsoft releases VSCode 1.0, a lightweight, fast, cross-platform IDE

Not only was it built on web technologies (Electron, TypeScript), but offered first-class JavaScript and TypeScript support. It quickly disrupted Sublime Text, Atom, and other full IDEs.



Microsoft announcing VSCode at the Microsoft Build conference in 2015.

ECMAScript 2016 is released, with exponential operator (**) and array.includes() method

Angular (Angular2) is released

Angular was a complete reimagining of the original AngularJS framework, written from scratch to address many of the original framework's shortcomings. Some key differences include replacing the Model-View-Controller with a component tree structure, embracing TypeScript which allowed for better overall tooling, and Ahead-of-Time compilation for performance and security. Angular became a top choice for large-scale enterprise applications due to its structure and opinionated framework.

Next.js 1.0 is released

Next.js began as a small framework for server-rendered universal JavaScript web applications, built on React, Webpack, and Babel. Next.js paved the way for full-stack React apps by making server-side rendering with React simple. With Next.js, developers can use React for content heavy, SEO-focused websites. This framework eventually becomes the default framework for production-grade React apps.

The initial commit for the Temporal proposal is created

The Temporal proposal was introduced as a solution to long-standing issues with the built-in Date object in JavaScript, such as lack of immutability, lack of time zone and day light savings time support, and inconsistent parsing. In 2021, the Temporal proposal was approved for inclusion in the ECMAScript standard. However, today, the only environments that support the Temporal API is Firefox Nightly and Deno.

Prettier 1.0 is released

Prettier, an opinionated code formatter that enforces a consistent code style by parsing code and reprinting it with its own set of rules, aimed to reduce time wasted in code reviews that were plagued by inconsistent formatting. Tools like ESLint were focused on detecting issues, but they did not automatically fix formatting, which Prettier introduced. Prettier also promoted a write first, format later workflow, leading to cleaner code and collaboration. It's impact extended beyond JavaScript: Python projects adopted Black, while Rust and Go projects added formatters as part of their toolchains, treating formatting as a non-negotiable build step.

ECMAScript 2017 is released with string padding, object.entries(), object.values(), async functions, and more

By 2017, browser support for fetch() was strong across all modern browsers (except IE11), and many developers were using async/await (with and without Babel).

<script>
  async function getData() {
    try {
      const response = await fetch("https://api.example.com/data");

      if (!response.ok) {
        throw new Error("HTTP error " + response.status);
      }

      const data = await response.text(); // or response.json() for JSON
      document.getElementById("result").textContent = data;
    } catch (error) {
      console.error("Fetch failed:", error);
      alert("Something went wrong!");
    }
  }
</script>

<button onclick="getData()">Load Data</button>
<pre id="result">Waiting for response...</pre>

Facebook launches Yarn, a new package manager

Yarn was created to address pain points of npm at the time: speed, reliability, and consistency. Yarn introduced concepts such as deterministic dependency resolution with yarn.lock, auto-caching packages, parallelized installs, and more.

Cloudflare launches Cloudflare Workers, allowing developers to run JavaScript at the edge

Cloudflare Workers ushers in the modern era of serverless edge computing by combining serverless principles with edge distribution (at the time with around 100 data centers and now with over 300) and fast, scalable isolation. Edge distribution meant serverless code can be executed close to end users, minimizing latency. Cold start times were also minimized, as Cloudflare Workers is built on lightweight V8 isolates (instead of containers or micro-VMs). The arrival of Cloudflare Workers not only transformed Cloudflare from a CDN company offering security and performance for websites to a full web application platform. This also paved the way for other platforms to add isolate-based edge functions, such as Netlify, Vercel, and Deno Deploy.

Google releases Puppeteer 1.0, marking a major milestone in browser automation tools

Unlike other browser automation tools like Selenium that required multiple language bindings, Puppeteer was built specifically for Node.js, offering a more modern, JavaScript-first API to control headless Chrome. Puppeteer's release established Chromium as the default browser engine for automation, led to the decline of PhantomJS, and influenced the development of frameworks like Playwright and Cypress.

TensorFlow.js is released, bringing machine learning to the browser via WebGL or WebGPU without needing compute

TensorFlow was released by Google in 2015 as an open-source machine learning (ML) network, and quickly became the go-to tool for ML research. TensorFlow.js lowered the barrier to entry for web developers to implement ML models without Python, as well as embedding ML models into web apps, unlocking real-time predictions and browser-based AI applications.

ECMA TC39 “Smooshgate” was resolved by renaming flatten to flat

In 2018, TC39 proposed adding a new method to JavaScript arrays called flatten to flatten nested arrays. However, this name clashed with an existing method used by the popular JavaScript library, MooTools, which defined that method in a way that was incompatible with the proposed implementation. In response, some TC39 members jokingly suggested renaming the method from flatten to smoosh. While not meant to be taken seriously, it gained traction in discussions and memes.

Ryan Dahl teases a new project in a talk about his regrets about Node

In 2018, Ryan Dahl announced a new JavaScript runtime named “Deno” (an anagram of Node) during his widely viewed talk “10 things I regret about Node”.

ECMAScript 2018 is released with rest/spread properties, async iteration, promise.finally(), and more

The JavaScript Foundation and the Node.js Foundation merge to form the OpenJS Foundation

At the time, the JavaScript open source ecosystem had been fragmented across multiple foundations, each managing different projects. There was the Node.js Foundation focused on Node.js and server-side JavaScript. Then, there was the JavaScript Foundation, (formerly the jQuery Foundation), which managed client-side libraries like jQuery, ESLint, and Lodash. Both foundations were operating independently, resulting in overlapping resources and fragmented support for JavaScript projects. However, with Node.js becoming the de facto backend runtime for JavaScript and the growth of frontend libraries, the merger aimed to unify governance and support JavaScript as a whole.

Node.js added experimental support for ECMAScript modules in v12.0.0

As JavaScript adopted ES modules as a way to modularize and share code, Node.js slowly follows suit. In v12.0.0, Node.js introduces the .mjs file extension, the type field in package.json, and new mechanisms for interoperability with CommonJS.

ECMAScript 2019 is released with object.fromentries(), string.trimstart() and more

Node.js stabilizes support for ECMAScript modules in v13.2.0

Node v13.2.0 marks the official stabilization of support for ECMAScript modules, a significant mile in the Node.js ecosystem. This brought Node.js in line with the modern JavaScript module system, allowing developers to use the standardize import and export syntax natively.

JavaScript makes it into space with SpaceX Dragon

This famous touchscreen interface below runs on Chromium and is fully written on JavaScript. In an AMA with the SpaceX software engineers, they cited choosing Chromium gave SpaceX access to lots of programmers skilled with the technology.

.

Deno 1.0 is released

Ryan Dahl announces the first major version of Deno, a batteries-included, complete toolchain for writing modern JavaScript. It launches as a single executable file with first class TypeScript support, opt-in permissions model, and HTTP imports.

Adobe sunset its Flash software, ending an era of videos and games that left an impression on internet culture

For the nolstagic, the Internet Archive has preserved Flash games and animations.



Who remembers this helicopter game?

Deno joins TC39, underscoring the company's vision of embracing JavaScript standards server-side

Internet Explorer 11 is retired

The retirement of IE11 marked the end of a two-decade-long era dominated by Internet Explorer, which was once the world’s most widely used browser. Due to many security vulnerabilities and lack of standards in IE11, this was a pivotal step towards advancing the web ecosystem towards a more standardized, secure, and performant future.

ECMAScript 2022 is released with top-level await, new class elements, static block inside classes, and more

Bun 1.0 is released

Another server-side JavaScript runtime (written in Zig) emerges that bills itself the most performant drop-in replacement for Node.js.

Node.js selects Rocket Turtle as its mascot after a design contest

The idea of a mascot had been discussed within the Node.js community for years. In 2023, Matteo Collina started a GitHub issue discussing a Node.js mascot, culminating in a design contest on Twitter. By February, the final design was selected: Rocket Turtle.

ECMAScript 2024 is released, featuring top-level await, decorators, toWellFormed() method for return well-formed Unicode strings, and more

JSR, a modern, open sourced JavaScript registry, is released

The Deno team introduces JSR, the JavaScript registry, which aims to offer a better experience with installing and publishing JavaScript. It only supports ECMAScript modules, can natively understand TypeScript, can work with npm, and offers cross runtime support for Deno, Bun, workerd, and more.

The legal battle against Oracle to #FreeJavaScript begins

When Ryan Dahl’s blog post asking Oracle to release the JavaScript trademark got some attention from the JavaScript community (and zero comment from Oracle), the Deno team wrote an open letter to Oracle with the intent to challenge Oracle’s ownership by filing a petition for cancellation with the USPTO, citing Trademark abandonment. This open letter received nearly 20,000 signatures, including from high profile individuals such as Brendan Eich, Isaac Z. Schlueter, and more. The legal battle is currently ongoing, but you can follow Deno’s X or Bluesky for updates.

Deno 2 is released

Deno 2 is a major update that touts the simplicity of Deno 1.x but with the backwards compatibility with legacy JavaScript such as Node and npm. With the launch, Deno became the first JavaScript runtime to publish a commercial.

TypeScript will be ported to Go

TypeScript, originally implemented in TypeScript/JavaScript, has long faced performance challenges as projects have scaled. To address this, Anders Hejlsberg began experimenting with a Go port of TypeScript. Early benchmarks have shown improved speed of around 10x, encouraging the TypeScript team to move forward with the Go port, naming it tsgo. The team plans to release the Go port of TypeScript as TypeScript 7.0, once it has sufficient feature parity with the JavaScript-based version.



Anders Hejlsberg introduces a new port of TypeScript.

Microsoft announces it will open source in VSCode’s Copilot Chat extension

As AI agentic coding heats up with several tools available for developers, Microsoft continues to champion open source by announcing it will license the GitHub Copilot Chat extension under the MIT license, with the eventual goal to make VS Code an open source AI editor. This move will encourage the community to refine and build upon common AI interactions across editors, improving the agentic coding experience across all tooling.