Rediscovering Vanilla JavaScript: Streaming and Simplicity in 2025

It’s been a while since I last wrote “pure” JavaScript.
Most of my days are spent deep in React, Next.js, or some flavor of TypeScript. Frameworks, bundlers, state managers — they’ve become second nature.

But recently, I had to drop all of that. No React, no fancy tooling, no abstractions. Just a single .js file and the browser.

And honestly? It felt… nostalgic.

Writing Vanilla Again

There’s something oddly refreshing about opening a file and typing:

document.querySelector("#btn").addEventListener("click", () => {
  console.log("Clicked!");
});

No hooks, no props, no imports. Just DOM + JS.
It reminded me of the first days I fell in love with frontend, when making a button respond to a click felt like magic.

At first, it felt restrictive — like I’d lost all my superpowers. But quickly, it turned into a fun reminder: frameworks are built on top of this. And vanilla still works beautifully.

Streaming with Vanilla

The most interesting part? Implementing streaming responses without any libraries.

Here’s a simplified example:

async function streamData(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  let result = "";
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    result += decoder.decode(value, { stream: true });
    updateUI(result);
  }
}

That’s it. No external package. No middleware. Just browser APIs doing the heavy lifting.
Ten years ago, this kind of real-time experience would’ve required websockets, heavy server setups, and a lot of frustration. Today, it’s just a built-in.

How Fast Things Have Changed

Going back to vanilla made me realize how much the frontend world has accelerated:

• Streams are native. You can process data chunk by chunk without hacks.
• The DOM API is friendlier. Features like querySelector feel obvious now, but they weren’t always.
• Tooling is optional. For certain tasks, you don’t need Webpack, Vite, or Babel.

It’s almost funny — I’ve been buried so deep in abstractions that I forgot how capable plain JavaScript has become.

Why This Matters

• Sometimes vanilla is all you need.
• Using it again gives you a new appreciation for the progress we’ve made.
• Frameworks are powerful, but stripping them away reminds you of the fundamentals.

I left this little project feeling both nostalgic and impressed. Nostalgic because it felt like going back to my early coding days, and impressed because vanilla JS in 2025 feels stronger than ever.

Final Thoughts

I’m not about to ditch React or Next.js — they solve real problems at scale.
But touching vanilla again reminded me: understanding the raw language makes you a better developer, no matter the stack.

And when the moment comes to drop the abstractions, you realize JavaScript itself has grown up a lot.