Skip to content

jQuery Won. That's Why You Stopped Hearing About It.

7 min read1 views[JavaScript]
Cover image for "jQuery Won. That's Why You Stopped Hearing About It."

I keep inheriting servers where the HTML is fine, the Django app behind it is boring, and the page still pulls in jQuery. Every couple of years someone announces that it is over. Then I deploy another site, and there it is, running the menu.

This is the version of the story I trust, from the side of the stack I actually live on.

The years the browsers would not agree

In 2006, writing for the browser meant writing for several browsers that barely shared a personality. Internet Explorer did things its own way. Firefox did them another way. Safari and Opera had their own opinions. A click that worked on your machine could fail on the machine of the person paying for the work. Asking the server for fresh data without reloading the page meant holding a different request object depending on who built the browser.

John Resig showed jQuery at BarCamp NYC in January 2006. The first stable release landed that August. The idea was small, which is why it spread. One way to find something on the page, change it, listen for what the user does, and talk to the server. The part where each browser bends the rules stays inside the library.

Picture a universal travel adapter from the years when every country had a different socket, and some of those sockets were wired wrong. You carried one brick. You stopped packing a separate cable for each border.

That brick got everywhere. Plugins turned ordinary needs — a date picker, a dialog, a table you could sort — into something you could drop on a page before lunch. Microsoft shipped jQuery with its own web tools. By the end of the 2010s, the public counts put it on about four out of five of the top million sites. That is what a default looks like after it has won.

What you were actually doing with it

A page is a tree. The document is the trunk, the sections are branches, and the buttons and paragraphs are leaves. jQuery was a calm way to point at a branch and ask for work.

You described the target the same way a stylesheet does: the submit button inside the form with this class. Then you listed the work. Change the label. Show a spinner. Run this when someone clicks. Each step handed you the same set of elements back, so the list read in order, like instructions to one clerk.

That clerk also made the trip to the server. Ajax is a request that leaves the page standing. Before the browsers settled, that request was a small pile of special cases. jQuery folded them into one errand: here is the address, here is the data, here is what to do when the answer arrives, here is what to do when it does not.

The other gift was the plugin shelf. The core stayed focused. Calendars, lightboxes, and form helpers were other people's code, shaped to hang off the same clerk. Plenty of those plugins were rough. Plenty of them were the reason a ticket closed on a Friday. I have maintained both kinds.

Three changes, one obituary

People talk about jQuery's fade as if one thing happened. Three things happened, and they do not cancel each other out.

The browsers grew up. Through the 2010s the platform absorbed the everyday jobs. Finding elements with a stylesheet-style description became built in. Adding and removing classes became built in. Listening for clicks in one consistent way became built in. Asking the server for data without a reload followed, a few years behind the rest. jQuery's habit of selecting things that way pushed the standard along. The adapter had been in enough bags that the sockets changed shape to match it.

When your destination uses the plug you already have at home, the brick stays in the drawer. You still own it. You still want it the week you fly somewhere with the old sockets.

The job changed shape. jQuery assumes the page is already there and you walk in to edit it. That fits a server-rendered site. A Django template goes out as HTML, and a little behavior sits on top. It fits a lot of what I still deploy.

Then screens started behaving like applications. The menu, the table, the form, and the dialog all depend on one pile of data, and that pile changes every few seconds. Editing the live page by hand gets tangled. One handler hides a row. Another counted the rows earlier. A third saved the old text. They work until they run in an order nobody wrote down.

React, Vue, and their relatives flipped the deal. You describe the screen you want for the current data. A library works out which pieces of the real page have to change.

The picture I use with backend people: jQuery is renovating a house with a hammer, one wall at a time, while the family still lives there. The framework approach reprints the floor plan whenever the data changes, and a crew rebuilds only the walls that differ. The reprint is heavy for a one-room cottage. It earns its keep once the house has thirty rooms and four people renovating them in the same week.

That tradeoff got treated as a house rule. Teams pulled in a full framework for a brochure site and a contact form. I have read those codebases. The form still posted to a Django view. The framework's real job was showing and hiding a menu. The hammer was the smaller tool, and the cottage did not need a reprint.

The mood changed. Around the middle of the 2010s, "you might not need jQuery" went from useful advice to a status signal. On a phone, on a page you care about loading quickly, shipping a whole library to toggle one class is waste. I agree with that. I have also watched a rewrite whose target was removing a single included file. The page worked. A few months later it worked again, with new bugs in the gap. The users never asked for the gap.

Where it is in 2026

jQuery 4.0 shipped in January 2026. Someone is still cutting releases. Late in 2026, the public measurements still find it on about 65% of the ten million most popular websites, down from just under 80% of that same kind of list around 2021, and still ahead of any other JavaScript library by a wide margin. A large share of that is WordPress, other content systems, booking widgets, intranets, and admin panels nobody has budget to replace.

A library on two thirds of the biggest sites is still doing a job. The conference talks moved. The script on the page stayed.

When I have to choose on a real project, I split it like this.

A new interface with a lot happening in the browser — filters, live updates, several panels that have to agree — wants a model that owns that data. jQuery will let you build it. The bill arrives later, as bug reports about order and stale text.

A server-rendered page that needs a menu, a confirm step, or a form that talks back to the server can use jQuery and stay boring. Boring is what I want at 2 a.m. The browser's own features are equally boring when you already know which browsers you support. I pick whichever one the next person on the repo already understands.

A working jQuery site can stay until there is a concrete reason to move: a feature that no longer fits, a browser you have to drop, a dependency you cannot patch. "It is old" is the same argument people aim at a Go service from 2019 that still answers correctly. I leave those running too.

The short version

jQuery took the mess of cross-browser page editing and turned it into one habit: describe the element, do the work, talk to the server. It spread so far that the browsers learned the habit, and a generation of us learned to think that way. When screens grew into applications, a different habit took the new work. jQuery stayed with the work it was built for, which is still most of the pages a normal person opens.

That is a success story with a smaller crowd around it. Those are allowed to keep running.

# Comments (0)

No comments yet. Be the first.

0/1000