Last week, I watched a junior data scientist spend three hours debugging a PyTorch model that wouldn't converge. The real problem wasn't the model architecture or the learning rate. It was the framework. She'd inherited a project built on an older version that handled tensor allocation differently, and the migration docs were... let's say "sparse." Three hours. For a version mismatch.
That's the thing nobody tells you about machine learning frameworks in 2025. The landscape isn't just crowded — it's fracturing. PyTorch and TensorFlow still dominate the conversation, but the ground beneath them is shifting. JAX is eating into research labs. ExecuTorch and ONNX Runtime are redefining deployment. And half the "new" frameworks you hear about are just wrappers around older ones with better marketing.
If you're trying to figure out which framework to bet your next project on, or why your current stack feels like it's fighting you, you're not alone. I've spent the last six months migrating models between frameworks, benchmarking inference speeds, and generally pulling my hair out so you don't have to. Here's what's actually happening.
PyTorch Won the Research War. But It's Losing Something Else.
Let's get the obvious out of the way. PyTorch owns research. According to the 2025 State of AI report from Papers with Code, over 78% of published papers that include code use PyTorch. TensorFlow sits around 12%. Everyone else fights for scraps.
Why? Dynamic computation graphs. That's the short answer. Researchers need to change model architectures mid-experiment, add weird custom layers, and debug with standard Python tools. PyTorch lets you do that. TensorFlow 2.x tried to catch up with eager execution, but by then the community had already moved.
But here's where it gets uncomfortable. PyTorch's dominance in research doesn't translate cleanly to production. I've deployed models with both frameworks, and PyTorch's "just Python" philosophy becomes a liability when you need reproducible builds, strict versioning, and optimized serving. TorchServe exists, sure. It's fine. It's not great. Compared to TensorFlow Serving or NVIDIA's Triton Inference Server, the deployment story still feels bolted on.
And then there's the mobile edge case. If you're shipping models to phones or embedded devices, PyTorch Mobile exists but feels like an afterthought. The documentation is thin. The performance benchmarks I've seen vary wildly depending on the hardware. It works. But you'll spend time you didn't plan to spend.
JAX Is Not a Framework. That's the Point.
If you've been in ML circles lately, you've heard about JAX. Google's research teams love it. DeepMind publishes with it. It's fast, composable, and maddeningly different from everything else.
JAX isn't really a deep learning framework. It's a numerical computing library with automatic differentiation and a just-in-time compiler. Think NumPy with superpowers. You don't get high-level layers or optimizers out of the box. You build those yourself, or you use Flax or Haiku on top.
This is both JAX's strength and its biggest barrier. The functional programming paradigm — pure functions, no side effects, explicit state passing — is elegant. It eliminates entire categories of bugs. But it also means you can't just port your PyTorch code. You have to rethink how you structure your model.
I tried rewriting a simple transformer in JAX last month. The training speed was genuinely impressive — about 40% faster than my PyTorch equivalent on the same TPU hardware. But the debugging experience was worse. Error messages in JAX trace through compiled code, so stack traces get abstract. You'll see references to "primitive operations" and "HLO computations" that don't map cleanly back to your Python. If you're not comfortable with functional programming concepts, the learning curve is steep.
Google's 2025 Cloud AI report notes that JAX adoption in production environments grew 3x year-over-year, but the absolute numbers are still small. It's a research tool that's slowly leaking into production, not the other way around.
The Deployment Layer Is Where Frameworks Actually Die
Nobody talks about this enough. You can train a model in any framework you want. The pain starts when you need to serve it.
ONNX Runtime has quietly become the most important piece of infrastructure in ML deployment. It's not a training framework — it's an inference engine that takes models from PyTorch, TensorFlow, JAX, or scikit-learn and optimizes them for whatever hardware you're running. CPU, GPU, NPU, FPGA — ONNX Runtime handles the translation.
Microsoft's 2025 developer survey found that 67% of enterprise ML deployments now use ONNX Runtime at some point in the pipeline. That number surprised me until I thought about it. Why would you lock yourself into a single framework's serving infrastructure when you can export to ONNX and switch later?
There's a catch, though. Not every operation converts cleanly. Custom CUDA kernels? Forget it. Complex control flow that depends on runtime values? Probably broken. I've spent entire afternoons debugging ONNX export failures where the error message was essentially "operation not supported" with no hint about which operation or why. The tooling is improving, but it's not seamless.
For mobile and edge deployment, ExecuTorch is the new thing worth watching. It's PyTorch's answer to TensorFlow Lite, built from the ground up for ARM processors and microcontrollers. Early benchmarks from Qualcomm's AI Hub show 2-3x inference speed improvements over the old PyTorch Mobile stack on Snapdragon devices. But it's still young. The operator coverage isn't complete, and you'll find yourself implementing custom delegates more often than you'd like.
What About TensorFlow? It's Not Dead.
I keep seeing "TensorFlow is dead" takes on social media. They're wrong. TensorFlow still dominates in two areas: production serving at scale and the TensorFlow Lite ecosystem.
If you're running models on Android phones, TensorFlow Lite is still the path of least resistance. The Google Play Services integration means models can be served without bundling them in your APK. The hardware acceleration through the Android Neural Networks API is mature. PyTorch Mobile and ExecuTorch are catching up, but they're not there yet.
TensorFlow Extended (TFX) also remains the most complete MLOps pipeline I've used. Data validation, transformation, model analysis, serving infrastructure — it's all there, and it works together. PyTorch's ecosystem is more fragmented. You'll piece together tools from different vendors and hope they play nice.
But TensorFlow's API churn has burned a lot of goodwill. Keras is now the official high-level API, which is fine, but the transition from TensorFlow 1.x to 2.x was brutal, and the lingering tf.compat.v1 stuff still confuses newcomers. Google's own teams seem split between TensorFlow and JAX, which doesn't inspire confidence about the long-term roadmap.
Here's What I Actually Do When Choosing a Framework
After years of getting burned by framework choices, I've settled on a decision process that's saved me a lot of grief. It's not glamorous, but it works.
For research and experimentation: PyTorch. No question. The ecosystem of pretrained models on Hugging Face, the debugging tools, the community support — it's the fastest path from idea to working prototype. If I'm exploring a new architecture or reading a paper with code, I'm using PyTorch.
For production serving on cloud GPUs: I train in PyTorch, export to ONNX, and serve with ONNX Runtime or NVIDIA Triton. This gives me framework flexibility and hardware-optimized inference. The ONNX conversion step adds friction, but the deployment flexibility is worth it.
For mobile deployment on Android: TensorFlow Lite, reluctantly. I don't love the TensorFlow ecosystem, but the Android integration is just better. On iOS, Core ML is actually the best option — Apple's tools for converting PyTorch models to Core ML have gotten surprisingly good.
For high-performance research on TPUs: JAX. If you have access to Google's TPU pods, JAX is the only framework that truly takes advantage of them. The performance difference is real, and the functional programming model maps cleanly to parallel hardware.
For quick prototypes that need to be shared: I've started using tools that abstract away the framework entirely. AI-Mind, for instance, lets me describe the model I want in plain language and generates the training pipeline. It's not going to replace framework expertise for production systems, but for the "I need a working prototype by Friday" scenarios, it's genuinely useful. The first 30 generations are free, so there's no reason not to try it when you're in a time crunch.
The Trend Nobody's Talking About: Framework Convergence
Here's a prediction that might age poorly: the distinction between frameworks is going to matter less over time.
Look at what's happening. ONNX Runtime can ingest models from any major framework. Hugging Face's transformers library abstracts away the underlying framework almost completely. Keras 3.0 now supports PyTorch, JAX, and TensorFlow as interchangeable backends. The industry is building layers on top of frameworks that make the choice less consequential.
This is good for practitioners and bad for framework vendors. When you can switch from PyTorch to JAX by changing one line of Keras configuration, why would you be loyal to any framework? The value shifts upward — to the tools, platforms, and abstractions that sit above the framework layer.
According to a 2025 O'Reilly survey on ML infrastructure, 41% of teams now use two or more frameworks in production, up from 18% in 2022. Framework monoculture is dying. The future is multi-framework pipelines glued together with ONNX and abstracted by high-level APIs.
What This Means for You Right Now
If you're starting a new project today, don't obsess over picking the "right" framework. Pick the one that has the best documentation for what you're building, the most active community for your domain, and a clean path to ONNX export. That's probably PyTorch for most people. It might be TensorFlow if you're deep in the Android ecosystem. It might be JAX if you're doing bleeding-edge research on TPUs.
But more importantly, invest in the skills that transcend frameworks. Learn how to debug computation graphs. Understand how different hardware backends affect performance. Get comfortable with ONNX conversion and optimization. These skills will outlast any individual framework's popularity.
And when you're stuck on a deadline and the framework is fighting you, remember that there are tools that can bypass the framework headache entirely. Describe what you need, get a working pipeline, and move on. The framework is a means to an end, not the end itself.
The state of ML frameworks in 2025 is messy, fragmented, and converging at the same time. Kind of like the field itself. The people who thrive won't be the ones loyal to a single stack — they'll be the ones who know how to navigate the mess.
Sources: Papers with Code, 2025 State of AI Report; Google Cloud AI, 2025 Annual Adoption Report; Microsoft Developer Survey, 2025; O'Reilly Media, ML Infrastructure Survey 2025; Qualcomm AI Hub, ExecuTorch Benchmarks 2025