The one-line version: jQuery became the plumbing of the internet by fixing the web’s biggest headache — then the web rebuilt its plumbing around jQuery’s design, and the tool became invisible because its ideas were everywhere.

The key takeaways

  • The problem was universal, not fashionable. In 2006 every browser disagreed about events, data fetching and finding elements. Every developer paid the same tax daily — which is why one small library could win the whole market.
  • The decisive design choice was politeness. jQuery wrapped browser objects instead of rewiring them. Its rivals monkey-patched the shared machinery, and the bill arrived twelve years later as SmooshGate — an entire language renaming a feature to avoid breaking old sites.
  • Distribution beat features. Microsoft shipped it in Visual Studio; WordPress, Drupal and MediaWiki baked it in. By the mid-2010s it ran on 75–80% of the web’s top properties.
  • The platform absorbed it. querySelector, classList, fetch() and Promises are jQuery’s ideas, shipped natively and free. Evergreen browsers then killed the quirks jQuery existed to tame.
  • Then the industry changed its mind about how UI is built. Imperative DOM editing gave way to declarative frameworks, where the interface is a function of state — and hand-editing the page becomes an anti-pattern.
  • Mindshare is not usage. After a decade of obituaries, jQuery still runs on 66.4% of all websites and about 86% of sites using any JavaScript library. React sits near 6%.
  • Inertia is a moat. jQuery has lost greenfield almost completely and still rules the installed base, because ripping it out of millions of working sites buys nothing and risks everything.
  • It isn’t a museum piece. jQuery 4.0.0 shipped on the project’s twentieth birthday — and internally uses Array.prototype.flat, the very feature that had to be renamed because of a rival’s bad manners.

1. The broken web

Imagine a world where every country uses a different electrical outlet, a different voltage and a different plug shape — and every appliance you build has to work in all of them. That was the web in 2006.

The first browser war had ended, but the peace was a mess. Internet Explorer 6 ruled the market and played by its own private rules. Firefox and Safari followed the official standards, more or less — inconsistently, and as the minority. Want a button to react when clicked? Internet Explorer used attachEvent, everyone else used addEventListener, and the two disagreed on how clicks even travelled through a page. Want to fetch data without reloading? Microsoft required a proprietary plugin; the others had a built-in feature. Every simple task — finding an element, changing it, reacting to a user, talking to a server — meant writing the same code two or three times, wrapped in defensive checks for whichever browser happened to be visiting.

Web developers of that era weren’t really building products. They were paying a tax, in time and sanity, to chaos.

2. A polite revolution

On 14 January 2006, a twenty-one-year-old developer named John Resig stood up at BarCamp NYC, an informal tech unconference, and showed a small JavaScript library he called jQuery.[1][3] The idea was a universal travel adapter for the web: write your code once, in jQuery’s clean little language, and jQuery silently translated it for whatever browser was on the other end.

The core move was almost embarrassingly simple to describe — find things on the page, then do things to them — and jQuery let you say both in a single flowing sentence of code. $('.item') meant “go find every element like this,” and you could chain the next instruction straight onto it. Underneath that friendly surface sat serious machinery, including a selector engine called Sizzle that could decode CSS selectors even on browsers too old to understand them natively.

But jQuery’s deepest design decision wasn’t cleverness. It was politeness.

Its main rivals, Prototype and MooTools, had taken a shortcut: they rewired the browser’s shared, built-in machinery — a practice known as monkey-patching.[4][5] Imagine a tenant who doesn’t like the building’s electrical panel, so they open it up and tape their own extra switches onto it. It works, until the landlord upgrades the panel and the whole building shorts out. jQuery refused to touch the shared panel. It wrapped browser elements in its own protective layer — the famous $() — and left the wiring exactly as it found it.

That choice looked like a technical nicety. Twelve years later, it looked like prophecy.

3. Vindication, twelve years later

In 2018, the committee that governs the JavaScript language tried to add a handy new built-in feature called flatten. They discovered they couldn’t ship it. Old websites still running MooTools had taped their own flatten switch onto the shared panel years earlier, and the new official version broke those sites catastrophically. The incident got a nickname: SmooshGate. In the end, an entire global programming language was forced to rename its own feature — from flatten to flat — to route around the bad habit of one aging library.

jQuery never caused a SmooshGate, because it never touched what it didn’t own. Resig had also done something his rivals hadn’t bothered with: he wrote clear, friendly documentation and actively nurtured a community around the project. That is the first lesson of the story — documentation and community are features, maybe the features. jQuery wasn’t the first tool of its kind. It was the first one ordinary people could actually learn.

4. The golden age

Then came the pile-up of legitimacy. In September 2008, Microsoft announced it would ship jQuery inside Visual Studio and ASP.NET — open source blessed by the biggest enterprise software company on earth. Nokia signed on too. WordPress, Drupal and MediaWiki — the engines behind enormous swaths of the internet — baked jQuery in as a default. A plugin economy bloomed around it: calendars, carousels, data tables, entire interface kits like jQuery UI.

By the mid-2010s, jQuery ran on 75 to 80 percent of the web’s top properties — one of the deepest market penetrations in the history of computing.[6] And notice how it got there: not by out-marketing anyone, but by becoming the default. That is the second lesson — distribution beats features. A good tool that’s bundled everywhere beats a better tool that isn’t.

5. The twist: absorbed by its own platform

Here is where the story turns, and it is the heart of the essay.

jQuery was so popular, and its way of doing things so obviously right, that it became a kind of living wish list for the web itself. The people who design the official standards — the W3C, WHATWG and TC39 committees — could see, with hard data, exactly what millions of developers actually wanted. So they built those things directly into every browser, free and by default:

  • jQuery’s “find elements” trick became the native querySelector.
  • jQuery’s class-toggling became the native classList.
  • jQuery’s $.ajax() data-fetching became the native fetch() and Promises.
  • jQuery’s little utilities became built-in features of the JavaScript language itself.

Meanwhile, browsers went “evergreen” — Chrome, Firefox, Safari and Edge began updating themselves automatically and continuously. The ancient, quirky browsers that jQuery existed to tame simply died out.

To extend the earlier metaphor: every country on earth finally standardized its electrical outlets — using jQuery’s adapter as the blueprint. In January 2014, two developers, Zack Bloom and Adam Schwartz, published a cheeky website called You Might Not Need jQuery, showing how to do all of its everyday tricks with plain, built-in browser features.[8] It landed like a manifesto. The universal adapter had become dead weight — because the world had rewired itself in the adapter’s image.

6. The deeper shift

And even if the browsers hadn’t caught up, jQuery faced a second, more philosophical disruption: the industry changed its mind about how interfaces should be built at all.

jQuery is imperative — it works like a micromanaging boss. When something happens, you give step-by-step orders: go find that box on the page, check what it says, change its colour, update the number. For simple pages this is fine. But as websites grew into full applications, the micromanagement broke down. With dozens of features all grabbing and editing the same page directly, nobody could say for sure what the page should look like at any moment. Bugs became ghosts — inconsistent, unreproducible, maddening.

The modern answer is declarative thinking, embodied by frameworks like React, Vue and Angular. Instead of giving orders, you describe the result you want, as a pure function of your data:

UI = f(state)

The interface is a reflection of the application’s state, and the framework handles the tedious re-arranging of the actual page. In that world, reaching in and hand-editing the page with jQuery isn’t just unnecessary — it’s an anti-pattern, like secretly editing a document that a system is managing. You corrupt the very bookkeeping that keeps everything consistent.

The industry ratified this shift publicly. In September 2018, GitHub’s engineers wrote up how they’d removed jQuery from one of the most-visited sites on earth — not by adopting a giant framework, but by using the now-capable native browser features.[9] And Bootstrap — for a decade the single biggest delivery truck carrying jQuery into new projects — rewrote itself without it: the jQuery-free Bootstrap 5 entered testing in June 2020 and shipped in May 2021.

7. The paradox of persistence

Given all that, you would expect jQuery to be dead. The developer world has certainly talked as if it were dead for a decade.

Here are the measured facts: jQuery still runs on 66.4% of all websites on the internet. Among sites that use any JavaScript library at all, its share is about 86%. Even among the thousand busiest sites on the web, it runs on three out of four. React — the fashionable modern framework that dominates conference talks and job postings — sits at roughly 6%.[12]

That gap between what developers say and what the internet runs is the third lesson: mindshare is not usage. Loud discourse is not data.

The explanation isn’t nostalgia; it’s economics. WordPress alone powers roughly 41% of the web, and thousands of its themes and plugins still depend on jQuery. For the businesses behind those millions of working sites, ripping out jQuery buys almost nothing and risks breaking everything. This is the difference between greenfield — new projects, where jQuery has lost almost completely — and the installed base, where it still rules. Once a tool is woven into critical workflows, the cost of switching protects it long after its technical advantage is gone. Inertia, it turns out, is a moat.

Nor is jQuery a museum piece. On 17 January 2026 — its twentieth birthday — the project released jQuery 4.0.0, its first major version in nearly a decade: modernized internals, ancient-browser support finally shed, deprecated features removed, security features like Trusted Types added.[11] And tucked into its source code is a detail with real poetry: jQuery 4 now internally uses Array.prototype.flat — the very feature the JavaScript language had to rename during SmooshGate because of a rival’s bad manners. The polite library inherited the world; the impolite one became a cautionary tale baked into the language’s vocabulary.

8. What jQuery teaches anyone who builds things

Strip away the code, and this story hands the same lessons to developers, product people and founders alike:

  • Solve a pain that’s universal, not fashionable. jQuery attacked a problem every web developer felt daily. Universality, not novelty, created adoption no marketing budget could buy.
  • Don’t modify what you don’t own. Build around shared systems, never into them. The bill for tampering always arrives — sometimes twelve years later, addressed to an entire industry.
  • Distribution beats features. jQuery didn’t just win hearts; it got bundled. Once you’re the default, you’re nearly impossible to remove.
  • Adoption is not mindshare. jQuery was declared dead for ten years while quietly running most of the internet. Measure reality, not the conversation.
  • The ultimate compliment is absorption. If your product fixes a platform’s flaw, the platform will eventually adopt your solution natively. That isn’t failure — but you had better know which stage of the lifecycle you are in: emerge, dominate, get absorbed, persist.
  • Great tools teach their users to outgrow them. jQuery educated the generation of developers who built the frameworks that displaced it. If your product creates the people who will disrupt you, build the next thing yourself.

9. The quiet victory

So how should history remember jQuery? Not as a tool that failed, and not even as a tool that faded. jQuery declined in relevance precisely because it succeeded in its mission: it unified a broken platform, proved what developers needed, and pressured the industry’s giants into delivering it — permanently, for everyone, for free.

Its fingerprints are now inside every browser on earth. Every time any developer, anywhere, finds an element on a page or fetches data from a server using nothing but built-in browser features, they are using jQuery’s ideas — whether or not they have ever typed a dollar sign.

The platform did not merely replace jQuery. It became jQuery.

References

  1. Resig, J. — 10th Anniversary of jQuery. johnresig.com/blog/10th-anniversary-of-jquery
  2. The Next Web — The most popular JavaScript library, jQuery, is now 10 years old. thenextweb.com
  3. Chall, A. — How jQuery was born: a brief history of the most popular JavaScript library. medium.com
  4. Stack Overflow — Why is it frowned upon to modify JavaScript objects’ prototypes? stackoverflow.com
  5. Kettanaito, A. — Why Patching Globals Is Harmful. kettanaito.com
  6. Admix Web — Celebrating the 20th Anniversary of jQuery. admixweb.com
  7. Metorial — The jQuery Age of AI Agents. metorial.com
  8. OpenReplay Blog — jQuery Alternatives for Modern JavaScript. blog.openreplay.com
  9. GitHub Engineering Blog — Removing jQuery from GitHub.com frontend (September 2018). github.blog
  10. Official jQuery Blog — jQuery 4.0.0 BETA! (February 2024). blog.jquery.com
  11. Official jQuery Blog — jQuery 4.0.0 (17 January 2026). blog.jquery.com
  12. W3Techs — Usage statistics and market share of jQuery. w3techs.com