PyTorch, JAX, and the Evolution of TensorFlow

Most developers treat their choice of ML framework like a religious conversion. They start with TensorFlow because it's what the tutorials use, move to PyTorch because the tensors actually make sense, and then eventually find themselves squinting at JAX because they want to do something truly weird with gradients. It's a predictable cycle of chasing the cutting edge, but the actual shift in momentum is harder to pin down than the anecdotes suggest.

I decided to stop guessing and just look at the data. By overlaying search trends from Hacker News, you can see the exact moment the community's collective brain shifted. TensorFlow owned the early gold rush, but PyTorch didn't just nudge it aside, it completely gutted it in the research labs between 2019 and 2021. Now, JAX is the new darling for anyone doing heavy lifting in 2023.

The most interesting part isn't the tools, though. It's the players. For a long time, OpenAI's dominance looked like a foregone conclusion, with their lead growing steadily through 2023. But then something happened in 2026. Anthropic didn't just catch up, they surged.

Watching that lead change hands in real time makes you wonder if we're seeing a genuine shift in capability or just a new cycle of hype.

The signal in the noise

Indexing 18 years of Hacker News comments is the only way to see what developers actually think about a tool versus what a marketing department says. Corporate blogs are polished, but HN is where people admit a library is a nightmare to configure or that a specific API version is broken. When you analyze this volume of data, you're not looking for a "consensus" (which rarely exists in tech), but for the delta between the official documentation and the actual user experience.

This part is genuinely confusing because sentiment analysis on developer forums is notoriously difficult. Developers use sarcasm, niche jargon, and a specific kind of aggression that standard NLP models often mistake for pure negativity. To get a real signal, you have to filter for high-karma comments and specific technical keywords.

import pandas as pd
from textblob import TextBlob

def get_dev_sentiment(df, keyword):
    # Filter for comments containing the keyword
    subset = df[df['text'].str.contains(keyword, case=False)]
    # Calculate average polarity (-1 is negative, 1 is positive)
    sentiments = subset['text'].apply(lambda x: TextBlob(x).sentiment.polarity)
    return sentiments.mean()

The dataset is massive. We're talking about millions of comments spanning nearly two decades. To make this usable, you need a pipeline that handles:

• Algolia API rate limits
• Deduplication of threaded conversations
• Cleaning of HTML artifacts in the text

It's a blunt instrument, but it's honest. It reveals that a tool's popularity is often inversely proportional to how much people enjoy using it.

The shift to PyTorch and JAX

PyTorch won the research war because it's intuitive. In 2019, the shift from TensorFlow to PyTorch happened because researchers hated the static graph. PyTorch's eager execution means the code behaves like standard Python; you can drop a print statement or a debugger into your forward pass and actually see what's happening. It's a fundamentally different mental model that prioritizes developer velocity over raw production optimization.

JAX is the current favorite for high-end research because it treats transformations as first-class citizens. It isn't a deep learning framework in the traditional sense; it's a library for composable function transformations. The magic is in jit (Just-In-Time compilation), vmap (vectorization), and grad (automatic differentiation). This part is genuinely confusing for people coming from PyTorch because JAX requires pure functions and immutable arrays. You can't just mutate a variable in place, or the compiler will lose its mind.

import jax.numpy as jnp
from jax import jit, grad

def f(x):
    return x**2

df_dx = jit(grad(f)) 
print(df_dx(3.0)) # Output: 6.0

The trade-off for JAX's speed is a steep learning curve. You have to manage your own state and handle random number generation explicitly, which feels tedious compared to PyTorch. But for large-scale model training, the ability to vectorize a function across 1,000 GPUs without writing manual MPI code is why it's dominating the new frontier of LLM research.

The TensorFlow gold rush

The cycle from TensorFlow to PyTorch to JAX shows that in ML, the "best" tool isn't the one with the most features, but the one that fits the current mental model of the people writing the papers. TensorFlow tried to be an all-in-one industrial platform before the community had even settled on how to debug a gradient. PyTorch won because it felt like writing Python. Now JAX is winning the research crowd because it treats transformations as first-class citizens. I think we're seeing a pattern where the industry optimizes for developer ergonomics for a few years, then swings back toward raw performance and mathematical purity once the abstractions get too heavy.

The HackerNewsTrends data makes this shift visible, but I'm not convinced the "winner" of any given era actually dictates the long-term architecture of the field. We've seen the "gold rush" mentality before—where everyone piles into a framework because it's the prerequisite for getting a paper accepted at NeurIPS—only to migrate the moment a more flexible API arrives. It's less of a technological evolution and more of a social one.

I wonder if we'll ever reach a point where the framework actually disappears into the background, or if we're just destined to repeat this cycle every four years with a new set of primitives.

Patterns of adoption

The transition from TensorFlow to PyTorch, and now toward JAX, isn't just a change in library preference. It's a signal that the "production-first" mindset of 2016—where we prioritized rigid graphs and deployment stability—has been replaced by a need for extreme flexibility and raw speed. TensorFlow tried to be a complete platform; PyTorch felt like a Python library. I think the current shift toward JAX suggests that the industry is moving even further away from "frameworks" and closer to the metal, treating ML more like high-performance computing than traditional software engineering.

Looking at the Hacker News trends, there's a lot of noise about JAX being the "next big thing." I'm skeptical that it will ever achieve the sheer ubiquity of PyTorch. PyTorch won because it was intuitive for people who already knew Python, and JAX requires a different mental model—functional programming and immutable arrays—that creates a much higher barrier to entry. Most developers aren't looking for the most mathematically pure way to write a tensor operation; they just want their code to run.

This leaves us with a weird gap. We have tools that are incredible for research and tools that are stable for production, but the bridge between the two is still clunky. I wonder if we're just cycling through tools until someone actually solves the deployment friction, or if the "research vs. production" split is just an inherent part of how this tech works.

Conclusion

The TensorFlow gold rush was a specific moment in time, driven as much by Google's marketing as by the actual code. Now that the dust has settled and PyTorch and JAX have taken over the research labs, it's clear that developer experience usually wins out over corporate ecosystem plays.

I'm still not sure if we've actually found the "correct" way to build these models, or if we're just settling on the tools that happen to be the least frustrating right now.

If you're still clinging to a legacy TF codebase, ask yourself: are you actually getting a performance benefit, or are you just used to the boilerplate?