The machine learning framework landscape in 2025–2026

PyTorch's monopoly over deep learning is now near-total, gradient boosting still dominates tabular data, MLOps has fused with LLMOps into unified platforms, and the LLM framework ecosystem has exploded into a multi-layered stack spanning inference engines, agent orchestrators, and fine-tuning toolkits. This report maps the full terrain across four categories — deep learning, classical ML, MLOps, and LLM frameworks — with architectural analysis, code examples, and practical guidance for a data intelligence team choosing tools in 2025–2026. The pace of change is uneven: classical ML frameworks evolve incrementally, deep learning has consolidated, and LLM tooling remains in a state of rapid flux where this month's dominant framework may be next month's legacy code.

Part I: Deep learning frameworks — PyTorch rules, compilation defines the era

PyTorch's commanding position

PyTorch now accounts for ~75% of NeurIPS 2024 papers and ~95% of models on Papers with Code. This is not a trend — it is a monopoly. The latest stable release, PyTorch 2.9.0 (October 2025), brought 3,216 commits from 452 contributors and continued the 2.x generation's defining feature: torch.compile.

The architectural philosophy remains "Python-first." PyTorch 2.0 actually moved code from C++ back into Python. The torch.compile system uses TorchDynamo (graph capture via Python frame evaluation) plus TorchInductor (Triton-based code generation) to deliver ~43% average speedup on A100 while preserving PyTorch's imperative, debuggable programming model. In 2025, it works on 93%+ of models with three modes: "default", "reduce-overhead", and "max-autotune".

Key PyTorch 2.9 additions include Symmetric Memory for multi-GPU kernels over NVLink/RDMA, FlexAttention on Intel GPUs, stable ABI for C++/CUDA extensions, and expanded wheel variants for ROCm, XPU, and CUDA 13. The distributed training story has matured via AutoParallel (compiler-driven discovery of data/tensor/expert parallelism), SimpleFSDP, and DTensor as a standard representation for sharded tensors.

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

class MNISTNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        return self.fc2(torch.relu(self.fc1(x)))

model = torch.compile(MNISTNet())  # One line for ~43% speedup
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_fn = nn.CrossEntropyLoss()

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('.', train=True, download=True,
                   transform=transforms.ToTensor()),
    batch_size=64, shuffle=True)

for epoch in range(5):
    for X, y in train_loader:
        loss = loss_fn(model(X), y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

PyTorch's weaknesses are narrowing but real: torch.compile debugging remains a "dark art" (graph breaks, recompilation surprises), mobile/edge deployment still trails TensorFlow Lite, and production serving via TorchServe is less mature than TF Serving.

TensorFlow's managed decline and Keras 3's pivot

TensorFlow's GitHub repository shows ~187K stars — an artifact of early accumulation, not current momentum. PyTorch overtook TensorFlow in Google search volume in May 2021 and the gap has widened since. Google's own research teams have shifted to JAX.

The most interesting development is Keras 3.0, a complete rewrite with a multi-backend architecture that runs on JAX, TensorFlow, PyTorch, and OpenVINO. Any Keras 3 model can be instantiated as a PyTorch Module, exported as a TF SavedModel, or used as a JAX function. In benchmarks, the JAX backend typically delivers the best training performance.

import os
os.environ["KERAS_BACKEND"] = "jax"  # or "tensorflow" or "torch"

import keras
from keras import layers

model = keras.Sequential([
    layers.Flatten(input_shape=(28, 28)),
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
model.fit(x_train / 255.0, y_train, epochs=5, batch_size=64)

TensorFlow retains genuine strengths in production: TF Serving remains the gold standard for model serving, TF Lite dominates mobile/edge, TF.js owns the browser, and TFX provides battle-tested enterprise pipelines. In Latin America, Africa, and parts of Asia, TensorFlow still predominates. But for new projects in research or startups, PyTorch is the default.

JAX brings functional elegance and 300% adoption growth

JAX has seen 300% adoption growth since 2022, powered by Google DeepMind using it to build Gemini and Gemma. Its architecture is built on functional programming: pure functions, immutable state, and four composable transformations — jax.jit (XLA compilation), jax.grad (automatic differentiation), jax.vmap (auto-vectorization), and jax.pmap (auto-parallelization).

The ecosystem has consolidated around Flax NNX (replacing the older Linen API and the deprecated Haiku), Optax for optimization, and Equinox as an alternative with a more PyTorch-like feel. JAX excels on TPUs with best-in-class distributed training support, but a well-known case study from Liquid AI documented painful multi-node GPU scaling issues that led them back to PyTorch — JAX shines on Google infrastructure but GPU multi-node NCCL scaling can be problematic.

import jax
import jax.numpy as jnp
from flax import nnx
import optax

class MLP(nnx.Module):
    def __init__(self, din, dmid, dout, *, rngs: nnx.Rngs):
        self.linear1 = nnx.Linear(din, dmid, rngs=rngs)
        self.linear2 = nnx.Linear(dmid, dout, rngs=rngs)

    def __call__(self, x):
        return self.linear2(jax.nn.relu(self.linear1(x)))

model = MLP(784, 128, 10, rngs=nnx.Rngs(0))
optimizer = nnx.Optimizer(model, optax.adam(1e-3))

@nnx.jit
def train_step(model, optimizer, x, y):
    def loss_fn(model):
        logits = model(x.reshape(-1, 784))
        return optax.softmax_cross_entropy_with_integer_labels(logits, y).mean()
    loss, grads = nnx.value_and_grad(loss_fn)(model)
    optimizer.update(grads)
    return loss

The rising challengers: MLX, tinygrad, and Modular

MLX (Apple, open-sourced December 2023, now at v0.30.6) is purpose-built for Apple Silicon's unified memory architecture, eliminating CPU↔GPU transfer overhead entirely. WWDC25 featured dedicated MLX sessions. With M5 Neural Accelerator support delivering 4x speedups over M4 for LLM time-to-first-token, MLX is the clear choice for local ML on Apple hardware — but it is Apple Silicon only, with no datacenter capability.

tinygrad (v0.12.0, ~31.4K GitHub stars) is George Hotz's minimalist framework that reduces all of deep learning to ~25 low-level ops. Its real ambition: building a completely sovereign software stack for AMD GPUs, bypassing ROCm entirely. The codebase is intentionally tiny and readable — excellent for learning how frameworks work internally.

Modular/Mojo raised $250 million in 2025 and open-sourced 500,000+ lines of GPU kernel code. Created by Chris Lattner (LLVM, Swift), Mojo aims to be a Python superset with C++/Rust-level performance. MAX Platform claims matrix multiplication matching cuBLAS and Flash Attention 3 implementation in Mojo instead of CUDA. The BentoML acquisition (February 2026) signals ambitions beyond inference. Mojo 1.0 is planned for H1 2026 — worth watching but not yet production-ready.

Non-Python alternatives worth knowing

Candle (Rust, Hugging Face, ~15K stars) enables serverless inference with lightweight binaries and no Python overhead, supporting GPT, LLaMA, Mistral, and Stable Diffusion. Burn is another rising Rust DL framework. Flux.jl (Julia, v0.15) offers a "fully hackable" pure Julia stack with excellent scientific computing integration through SciML. The common pattern: prototype in Python, optimize bottlenecks in Rust or deploy at the edge without Python.

Part II: Classical ML — gradient boosting still wins on tabular data

The big three boosting frameworks compared

Multiple large-scale benchmarks confirm what practitioners already know: for tabular/structured data, gradient boosting remains the most practical, cost-effective approach. A 176-dataset study found tree-based methods outperform deep learning in accuracy and require less computational time. XGBoost outperformed all deep learning models for both classification and regression in a 2025 ScienceDirect benchmark of 111 datasets and 20 models.

The three dominant gradient boosting frameworks have distinct architectural philosophies:

XGBoost 3.1.2 (November 2025) uses level-wise tree growth with L1/L2 regularization. Version 3.0 was a major milestone with reworked external memory supporting distributed training and NVLink-C2C for terabyte-scale data. Version 3.1 introduced a category re-coder that saves and re-codes string categories automatically. XGBoost is the most consistent performer across benchmarks and has the widest language support (Python, R, Java, Scala, C++, Julia).

LightGBM 4.6.0 (February 2025) uses leaf-wise tree growth — always splitting the leaf with the largest error reduction — plus GOSS (gradient-based sampling) and EFB (exclusive feature bundling). This makes it ~7x faster than XGBoost on large datasets with the lowest memory footprint, though it can overfit on small datasets and requires more careful tuning.

CatBoost 1.2.10 (February 2026) uses symmetric (balanced) trees and ordered boosting to prevent target leakage. Its killer feature: native categorical feature handling requiring zero preprocessing. CatBoost delivers the best out-of-the-box defaults and claims 30–60x faster prediction than XGBoost/LightGBM.

Here is the same classification task across all three, plus scikit-learn's histogram-based gradient boosting:

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import time

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# --- scikit-learn HistGradientBoosting (v1.8) ---
from sklearn.ensemble import HistGradientBoostingClassifier
sk_model = HistGradientBoostingClassifier(max_iter=200, learning_rate=0.1, max_depth=6)
sk_model.fit(X_train, y_train)
print(f"sklearn: {accuracy_score(y_test, sk_model.predict(X_test)):.4f}")

# --- XGBoost (v3.1) ---
import xgboost as xgb
xgb_model = xgb.XGBClassifier(n_estimators=200, learning_rate=0.1, max_depth=6,
                                eval_metric='logloss', random_state=42)
xgb_model.fit(X_train, y_train)
print(f"XGBoost: {accuracy_score(y_test, xgb_model.predict(X_test)):.4f}")

# --- LightGBM (v4.6) ---
import lightgbm as lgb
lgb_model = lgb.LGBMClassifier(n_estimators=200, learning_rate=0.1, max_depth=6,
                                num_leaves=31, random_state=42, verbose=-1)
lgb_model.fit(X_train, y_train)
print(f"LightGBM: {accuracy_score(y_test, lgb_model.predict(X_test)):.4f}")

# --- CatBoost (v1.2.10) ---
from catboost import CatBoostClassifier
cat_model = CatBoostClassifier(iterations=200, learning_rate=0.1, depth=6,
                                random_seed=42, verbose=0)
cat_model.fit(X_train, y_train)
print(f"CatBoost: {accuracy_score(y_test, cat_model.predict(X_test)):.4f}")

# Typical results: All achieve ~96-97% accuracy on this dataset.
# LightGBM trains fastest; CatBoost requires least tuning.

scikit-learn evolves with GPU support and free-threaded Python

scikit-learn 1.8.0 (December 2025) introduced Array API support enabling GPU computation via PyTorch and CuPy arrays — a significant shift for a library historically bound to NumPy and CPU. Version 1.7 added explicit validation sets for HistGradientBoosting early stopping and experimental free-threaded CPython support, potentially removing GIL limitations. The consistent fit/predict/transform API across 50+ algorithms remains unmatched for prototyping and education.

RAPIDS cuML delivers zero-code GPU acceleration

The most impactful classical ML development of 2025 may be RAPIDS cuML 25.02's cuml.accel — a zero-code-change GPU accelerator for scikit-learn. Add one line and existing scikit-learn code runs on GPU: 50x speedup for scikit-learn, 60x for UMAP, 175–250x for HDBSCAN.

# In Jupyter: just load the extension
%load_ext cuml.accel

# Existing scikit-learn code runs unchanged on GPU
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=500_000, n_features=100, random_state=42)
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X, y)  # Automatically GPU-accelerated — up to 50x faster

This is pre-installed in Google Colab and uses CUDA unified memory so datasets can exceed GPU memory by leveraging host RAM.

Polars is reshaping the data layer

Polars 1.38.1 (February 2026), written in Rust on Apache Arrow, now delivers 30x+ faster TPC-H benchmark performance over pandas with 87% less memory on CSV loading. Its lazy evaluation, multi-threaded execution, and query optimization (predicate pushdown, column pruning) make it the clear choice for heavy feature engineering. That said, 82% of users still rely on pandas for <1M row tasks — the hybrid approach (Polars for ETL, pandas for ML integration) is the 2025 pragmatic consensus.

import polars as pl

# Lazy evaluation with automatic query optimization
features = (
    pl.scan_parquet("data.parquet")
    .with_columns([
        pl.col("amount").log1p().alias("log_amount"),
        pl.col("amount").rolling_mean(window_size=7).alias("rolling_avg"),
        (pl.col("feature_a") / pl.col("feature_b")).alias("ratio_ab"),
    ])
    .collect()  # Executes optimized plan
)
X = features.select(["log_amount", "rolling_avg", "ratio_ab"]).to_numpy()

AutoML and emerging tabular methods

FLAML (Microsoft) deserves attention for its budget-aware optimization — three lines to try LightGBM, XGBoost, and Random Forest within a time budget. AutoGluon (Amazon) beat 99% of Kaggle competitors in tests through multi-layer model stacking. Meanwhile, Tabular Foundation Models like TabPFN represent the emerging frontier: pre-trained transformers that do in-context learning on tabular data with no per-dataset retraining. A 2025 benchmark by Zabërgja et al. claims recent deep learning methods (RealMLP, TabM, TabPFN) now outperform classical approaches under fair comparison conditions — though the practical consensus still favors gradient boosting for most production tabular workloads.

Part III: MLOps — the merge with LLMOps is the defining trend

MLflow 3.0 bridges traditional ML and generative AI

MLflow 3.0 (GA June 2025) represents the most significant MLOps platform shift of 2025. With ~19K GitHub stars and millions of users, MLflow expanded from experiment tracking into a unified ML + GenAI platform. The key additions: LoggedModel (connecting models to exact code, prompt versions, and evaluation runs), GenAI observability via full OpenTelemetry integration with auto-instrumentation for 20+ frameworks (OpenAI, LangChain, LlamaIndex, Anthropic), a Prompt Registry for centralized prompt versioning, and multi-turn conversation evaluation with LLM-as-judge scoring.

import mlflow

# Traditional ML tracking (unchanged)
with mlflow.start_run():
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_metric("accuracy", 0.95)
    mlflow.sklearn.log_model(model, name="my_model")

# NEW in MLflow 3: GenAI auto-tracing
mlflow.openai.autolog()  # Auto-traces all OpenAI calls
# Or: mlflow.langchain.autolog() for LangChain

Serverless MLflow on AWS SageMaker launched in December 2025 — no-charge, auto-scaling. The convergence of traditional ML tracking and LLM observability in a single platform is MLflow 3's strongest argument for adoption.

The experiment tracking landscape: MLflow vs W&B

Weights & Biases offers the best-in-class experiment visualization and collaboration UI, with ISO 27001/SOC 2/HIPAA compliance and deep integrations with PyTorch, Hugging Face, and Lightning. Its 2025 addition of Weave — a GenAI toolkit for tracing, evaluation, and observability — mirrors MLflow 3's convergence strategy. Team plans start at ~$1,000/month for 10 users.

The choice often comes down to: MLflow for open-source, self-hosted, vendor-neutral tracking; W&B for superior visualization, collaboration, and managed experience with a budget for commercial tooling. Both now address LLMOps.

Workflow orchestration: three philosophies

Apache Airflow 3.0 (GA April 2025) is the biggest update in platform history with DAG versioning (most requested feature ever), event-driven scheduling, and multi-language task SDKs. With 30M+ monthly downloads and 80,000+ organizations, it is the industry standard — 70% of Fortune 500 data stacks. 30% of users now use Airflow for MLOps.

Metaflow (Netflix, v2.19.16) takes a "human-centric" approach where flows are DAGs with Python instance variables for state, automatic versioning of all code and data, and a new spin command (November 2025) that enables notebook-like iteration on individual steps. Recursive and conditional steps (August 2025) enable building agentic AI systems. Used by Netflix, Goldman Sachs, DoorDash.

ZenML (v0.85.x) provides the most aggressive infrastructure abstraction — swap backends between Kubernetes, SageMaker, and Vertex AI without changing pipeline code. Its October 2025 Pipeline Deployments transform any pipeline into a persistent HTTP service. The positioning has shifted to "One AI Platform from Pipelines to Agents."

# Metaflow: flows as Python classes with automatic state management
from metaflow import FlowSpec, step

class TrainingFlow(FlowSpec):
    @step
    def start(self):
        self.data = load_dataset()
        self.next(self.train)

    @step
    def train(self):
        from sklearn.ensemble import RandomForestClassifier
        self.model = RandomForestClassifier().fit(self.data["X"], self.data["y"])
        self.next(self.end)

    @step
    def end(self):
        print(f"Score: {self.model.score(self.data['X_test'], self.data['y_test'])}")

if __name__ == "__main__":
    TrainingFlow()

Model serving and distributed compute

BentoML 1.4.35 provides the easiest path from model to production API with Python-native service definitions, automatic Docker containerization, and strong LLM serving via vLLM backend. Ray (~35K GitHub stars, used by OpenAI and Uber) remains unmatched for distributed computing at scale — Ray Serve's November 2025 additions include async inference, custom request routing, and stateful autoscaling policies. For teams needing model composition and fractional GPU support, Ray is the clear choice.

Practical MLOps stacks

For a startup or small team: MLflow (tracking) + DVC (data versioning) + Prefect (orchestration) + BentoML (serving). For enterprise: Databricks/MLflow + Kubeflow (pipelines) + Feast (feature store) + Ray Serve + Evidently (monitoring). For GenAI-first: MLflow 3 (tracing + eval) + LangChain (framework) + ZenML (orchestration) + Ray Serve (inference) + Langfuse (observability). The global MLOps market was valued at ~$2.2B in 2025 and is projected to reach $35.4B by 2033.

Part IV: LLM frameworks — the fastest-moving category

The inference performance hierarchy

LLM inference has become a three-way race. On H100 with Llama 3.1 8B:

SGLang (v0.4, deployed on 400,000+ GPUs) innovates with RadixAttention — a radix tree-based KV cache that preserves cache across requests, delivering 3–5x cache hit rate improvement in multi-turn conversations. vLLM compensates with the largest community (10K+ contributors), broadest model coverage, and fastest time-to-first-token. LMDeploy delivers 99.5% of SGLang's throughput with trivial installation (pip install lmdeploy). Modular MAX claims 6% faster than SGLang on Qwen3-8B, though it is less battle-tested.

Ollama (v0.8–0.9) remains the de facto standard for local LLM development — two commands to install and run any of 100+ models with an OpenAI-compatible API:

curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.2

import ollama
response = ollama.chat(model='llama3.2', messages=[
    {'role': 'user', 'content': 'Explain gradient boosting in 3 sentences'}
])

Hugging Face Transformers v5 goes PyTorch-only

Transformers v5.0.0 (late 2025) is the first major release in five years, with 3M+ daily pip installs and 1.2 billion total. The headline decision: PyTorch-only backend — TensorFlow and Flax support are sunset. The modular architecture introduces a unified AttentionInterface, dramatically reducing code duplication. The tokenizer redesign removes the "Fast" vs "Slow" distinction. Weekly releases start from v5.1. With 400+ model architectures and 750K+ checkpoints on the Hub, Hugging Face remains the central model distribution platform.

LangChain, LangGraph, and the complexity debate

LangChain (1.0, October 2025, 80K+ GitHub stars) has explicitly pivoted: the team now recommends "Use LangGraph for agents, not LangChain." LangChain remains strong for document Q&A and RAG pipelines, but LangGraph is the recommended path for anything involving cycles, state, or multi-step agent logic.

The 2025 consensus among senior developers: LangChain is overkill for simple RAG apps. Many prefer vanilla Python + direct OpenAI/Anthropic APIs + a vector store. The recommended mental model:

• Simple RAG: Direct API calls + LlamaIndex or Chroma — no framework needed
• Complex stateful agents: LangGraph for graph-based orchestration with time-travel debugging
• Data-heavy retrieval: LlamaIndex for ingestion, indexing, and hybrid search

LlamaIndex achieved a reported 35% boost in retrieval accuracy in 2025 and added AgentWorkflows for multi-step orchestration. It remains the best choice for document-heavy RAG applications where ingestion quality matters most.

DSPy replaces prompt engineering with programming

DSPy 3.1.3 (February 2026, 160K+ monthly downloads) represents the most intellectually distinctive framework in the LLM space. Created at Stanford NLP and now at Databricks, its thesis: shift from ad-hoc prompting to programming LLMs. You declare input/output signatures and modules, and DSPy's optimizers automatically compile programs into optimized prompts and weights.

import dspy

dspy.configure(lm=dspy.LM("openai/gpt-4o-mini"))

# Declarative: specify what, not how
classify = dspy.Predict("text -> sentiment: str")
result = classify(text="DSPy makes LLM programming systematic")

# Multi-hop RAG with automatic optimization
class MultiHop(dspy.Module):
    def __init__(self):
        self.retrieve = dspy.Retrieve(k=3)
        self.generate = dspy.ChainOfThought("context, question -> answer")

    def forward(self, question):
        context = self.retrieve(question).passages
        return self.generate(context=context, question=question)

# Automatic few-shot optimization
from dspy.teleprompt import BootstrapFewShot
optimizer = BootstrapFewShot(metric=my_metric)
optimized_program = optimizer.compile(MultiHop(), trainset=train_examples)

DSPy 3.0 (August 2025) introduced the GEPA optimizer with multimodal support, dspy.Reasoning for capturing native reasoning, and MLflow integration. The framework eliminates prompt engineering brittleness but has a learning curve and optimizer runs can be expensive.

The agent framework explosion

The multi-agent space has fragmented into tiers:

CrewAI ($18M Series A, 60% Fortune 500 adoption, 100K+ daily agent executions) offers the fastest path to working multi-agent prototypes with its role/task/crew abstraction. But multiple teams report hitting its ceiling 6–12 months in and rewriting to LangGraph. Microsoft merged AutoGen with Semantic Kernel (October 2025) into a unified Microsoft Agent Framework with GA planned Q1 2026, providing enterprise SLAs and SOC 2/HIPAA compliance.

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Research Analyst",
    goal="Find key market trends",
    tools=[search_tool, web_rag_tool]
)
research_task = Task(
    description="Analyze Q3 market trends",
    expected_output="Market analysis report",
    agent=researcher
)
crew = Crew(agents=[researcher], tasks=[research_task])
result = crew.kickoff()

LiteLLM and the API gateway layer

LiteLLM (v1.65+, 8ms P95 latency at 1,000 RPS) provides a unified OpenAI-compatible API to 100+ LLM providers. Its 2025 additions include an Agent Gateway (A2A) for invoking LangGraph and Azure agents through a unified interface, MCP support, and the Responses API for calling Anthropic and Gemini via OpenAI's format. TensorZero (Rust-based) claims 25–100x lower latency under heavy load for teams with extreme performance requirements.

from litellm import completion

# Same interface, any provider — swap with one string change
response = completion(model="openai/gpt-4o", messages=[{"role": "user", "content": "Hello"}])
response = completion(model="anthropic/claude-sonnet-4-20250514", messages=[{"role": "user", "content": "Hello"}])
response = completion(model="ollama/llama3.2", messages=[{"role": "user", "content": "Hello"}],
                      api_base="http://localhost:11434")

Fine-tuning has been democratized

Unsloth achieves 2–5x speedup with 80% less VRAM for single-GPU fine-tuning — a 70B model in INT4 uses 35–40GB instead of 140GB. Axolotl (v0.8.x) provides the most flexibility with open-source multi-GPU support. Torchtune is the PyTorch-native option for deep customization. LLaMA-Factory offers a no-code UI supporting 100+ models. For multi-node scale, DeepSpeed remains the gold standard.

Cross-cutting trends shaping 2025–2026

The compilation convergence. PyTorch's torch.compile, JAX's XLA, and Triton-based kernel generation share a common vision: write Python, get optimized GPU code. This is the dominant technical trend across deep learning frameworks.

Apache Arrow as universal interchange. Polars, cuDF, scikit-learn's Array API, and the broader data ecosystem are converging on Arrow for zero-copy data interoperability. This is quietly reshaping how data flows between frameworks.

OpenTelemetry as the observability standard. MLflow 3, Arize Phoenix, and other monitoring tools are converging on OpenTelemetry for unified tracing across ML and traditional software stacks, preventing vendor lock-in.

The "two-language problem" is being attacked from multiple angles. Mojo (Python superset with C++ speed), Rust frameworks (candle, Burn, linfa, Polars), and Julia (Flux.jl, Lux.jl) each attempt to eliminate the Python-for-prototyping / C++-for-performance split. Mojo is the most ambitious bet; Rust is the most pragmatic.

LLM frameworks are stratifying into specialized layers. The monolithic framework era is ending. Production stacks now combine: an inference engine (vLLM/SGLang), an orchestration layer (LangGraph), a data/retrieval layer (LlamaIndex), an API gateway (LiteLLM), an optimization layer (DSPy), and an observability layer (MLflow 3/Langfuse). Understanding these layers matters more than mastering any single framework.

Conclusion

The most important insight for a data intelligence team in 2025 is that framework selection is increasingly about composing layers, not picking monoliths. PyTorch + gradient boosting + MLflow 3 form a solid foundation. For LLM work, understanding the inference/orchestration/retrieval/gateway stack is more valuable than deep expertise in any single tool. The frameworks that stand out — torch.compile, RAPIDS cuml.accel, DSPy, SGLang — share a common trait: they deliver performance or capability gains through architectural innovation rather than just feature accumulation. For a coding club, the highest-impact activities would be hands-on comparisons of the same task across frameworks (as shown in this report's code examples), exploring torch.compile and cuml.accel as "free performance" upgrades, and building a simple RAG pipeline with direct APIs before reaching for LangChain — understanding what the abstractions do before adopting them.