jQuery

jQuery is a fast, compact JavaScript library whose famous tagline — “write less, do more” — captures exactly what it set out to achieve. It wraps the awkward, inconsistent browser APIs of the mid-2000s in a single, friendly object, accessed through the $ function, and lets developers select page elements with CSS selectors, manipulate them, attach event handlers, animate them, and talk to servers over Ajax using terse, chainable expressions that behave the same across every browser. First announced by John Resig in January 2006, jQuery went on to become one of the most widely deployed pieces of code in the history of the web, for many years appearing on the large majority of sites that used any JavaScript library at all.

Strictly speaking jQuery is a library, not a programming language — every jQuery program is JavaScript. But in practice it defined its own idiom so completely that for a generation of front-end developers “writing JavaScript” and “writing jQuery” were nearly synonymous. Its selector-and-chain style became a de facto dialect of the web.

History & Origins

jQuery was created by John Resig, who began experimenting with the idea while a student and developer frustrated by the state of cross-browser scripting. In the mid-2000s, the same task — finding an element, changing its style, wiring up a click handler, or making a background request — required different, fiddly code for Internet Explorer, Firefox, Safari, and Opera. Developers spent enormous effort papering over these differences.

Resig publicly unveiled jQuery on 14 January 2006 at the first BarCampNYC. The pitch was simple and immediately compelling: use the CSS selector syntax web developers already knew to grab elements, then act on them with a small, consistent vocabulary of methods. The library spread quickly through the early social-bookmarking and tech-blog scene, and the first stable release, jQuery 1.0, followed on 26 August 2006.

Adoption accelerated rapidly. The Drupal content-management system folded jQuery into its core, and over the following years major companies — including Microsoft, which shipped it with ASP.NET and on its CDN — adopted it. By the early 2010s jQuery had become the default front-end tool, taught in tutorials everywhere and assumed present in countless codebases.

As the project grew it gained institutional backing. The jQuery Foundation was established to steward the library and its sister projects; in 2016 it merged with the Dojo Foundation to form the JS Foundation, which in 2019 combined with the Node.js Foundation to create the OpenJS Foundation, jQuery’s current home.

Design Philosophy

jQuery’s design rests on a few ideas that, taken together, made it irresistibly easy to pick up.

• Select, then act. Almost everything begins with a selection: $(selector) returns a jQuery object wrapping the matching DOM elements. CSS selectors — including the same class, ID, attribute, and pseudo-class syntax used in stylesheets — are the universal addressing scheme.
• Implicit iteration. A jQuery object can wrap zero, one, or many elements, and methods operate on all of them at once. $(".item").hide() hides every matching element with no explicit loop.
• Chaining. Most methods return the jQuery object itself, so calls can be strung together fluently: $("#box").addClass("active").fadeIn().on("click", handler). This reads like a sentence and reduces boilerplate dramatically.
• Cross-browser normalization. Under the hood, jQuery smooths over differences in the DOM, the event model, and XMLHttpRequest so that a single line of code behaves identically everywhere — the single biggest reason for its early success.
• Write less, do more. The library deliberately optimizes for short, expressive code over raw flexibility, hiding the verbose native APIs behind compact helpers.
• Extensibility via plugins. A simple plugin pattern ($.fn.myPlugin = function () { ... }) let anyone add new chainable methods, spawning a vast ecosystem of third-party plugins for sliders, date pickers, validation, and more.

Key Features

Selectors and traversal

jQuery selects elements with CSS-selector syntax and then offers a rich set of traversal methods (parent(), children(), find(), closest(), next(), filter()) to move around the DOM tree:

1
2

// Select all checked checkboxes inside the form, then their labels
$("form :checkbox:checked").closest("label").addClass("selected");

DOM manipulation

Reading and writing content, attributes, and styles is concise:

1
2
3

$("#status").text("Saved").addClass("ok");
$("ul").append("<li>New item</li>");
$("img").attr("loading", "lazy");

Events

A unified event API handles binding, delegation, and custom events across browsers:

1
2
3
4

// Event delegation: handle clicks on any current or future .row
$("#table").on("click", ".row", function () {
  $(this).toggleClass("highlight");
});

Effects and animation

Built-in effects made simple animations a one-liner long before CSS transitions were universal:

1
2

$("#panel").slideToggle(300);
$(".alert").fadeOut("slow");

Ajax

jQuery popularized easy asynchronous requests, and $.ajax (with shorthands like $.get and $.getJSON) hid the messy details of XMLHttpRequest:

1
2
3

$.getJSON("/api/users", function (users) {
  $.each(users, (i, u) => $("#list").append(`<li>${u.name}</li>`));
});

Since jQuery 3.0 the Ajax methods return Promise-compatible objects, aligning with modern asynchronous patterns.

The Ecosystem

jQuery anchored a family of related projects:

• jQuery UI — interactions (drag, drop, resize, sortable), widgets (datepicker, dialog, autocomplete), and a theming system.
• jQuery Mobile — a touch-optimized framework for mobile web applications.
• Sizzle — the standalone CSS selector engine extracted from jQuery, reusable on its own.
• QUnit — a JavaScript unit-testing framework that grew up alongside jQuery.
• A plugin universe — thousands of community plugins, from carousels to form validators, all sharing the same chainable conventions.

Evolution

jQuery’s major versions trace the evolution of the web platform itself:

• 1.x established the core and supported even ancient versions of Internet Explorer.
• 2.0 (2013) dropped Internet Explorer 6–8 to slim down, while the 1.x line continued for sites still needing legacy support.
• 3.0 (2016) modernized internals, adopted Promise/A+-compliant Deferreds, and tightened standards compliance.
• 3.7.1 (2023) remained the long-lived stable release of the 3.x branch.
• 4.0.0 (January 2026) marked the biggest modernization in years: the source moved to ES modules, long-deprecated helpers such as jQuery.trim, jQuery.isArray, jQuery.parseJSON, and jQuery.type were removed in favor of native equivalents, Trusted Types support was added for stronger security, and the build was trimmed.

Current Relevance

The web changed in ways that reduced jQuery’s necessity. Browsers converged on standards, and native APIs absorbed many of jQuery’s best ideas: document.querySelectorAll brought CSS-selector querying into the platform, fetch replaced hand-rolled XMLHttpRequest, classList and the modern DOM made manipulation easier, and CSS transitions and animations handled effects declaratively. At the same time, component frameworks like React, Vue, and Angular shifted front-end development toward declarative, state-driven UI rather than direct DOM manipulation. High-profile signals followed — Bootstrap removed its jQuery dependency in version 5 (2021), and GitHub publicly migrated away from it.

Yet jQuery is far from dead. Browser-usage surveys still report it present on a very large share of existing websites — an immense installed base in WordPress sites, content-management systems, enterprise applications, and long-lived projects. The library remains actively maintained under the OpenJS Foundation, as the 2026 release of jQuery 4.0.0 demonstrates. For small projects, progressive enhancement, and the maintenance of existing code, jQuery is still a pragmatic, low-friction choice.

Why It Matters

Few libraries have shaped how a generation writes code as profoundly as jQuery. It democratized front-end development at a moment when cross-browser scripting was genuinely painful, letting designers and beginners accomplish in one readable line what previously took a dozen brittle ones. Its conventions seeped into the language and the platform: the $ idiom, the select-then-chain style, and the expectation that CSS selectors should work in JavaScript all trace lineage to jQuery, and the standardized Selectors API (querySelectorAll) was driven in part by the patterns jQuery made ubiquitous.

jQuery also proved the power of a focused, well-documented open-source library with a welcoming community and a strong plugin ecosystem — a template many later projects followed. Even as modern frameworks supersede it for new applications, jQuery’s fingerprints are all over today’s web, and its core lesson endures: meet developers where they are, hide the incidental complexity, and let them write less, do more.