• Fixed-step ODEs CPU ✓ GPU ✓ A step written for one sample, run over the batch until every sample is done.
• Differentiable sensitivities CPU ✓ GPU ✓ Generated forward- and reverse-mode derivatives, read by jax.grad, torch autograd and wp.Tape.
• Zero-copy hand-over (DLPack) CPU ✓ GPU ✓ Runs inside your JAX, PyTorch, Warp, CuPy and NumPy programs, and theirs inside its batches; DLPack hand-over certified with all five.
• Per-sample models and RHS CPU ✓ GPU ✓ You write one step of one sample; the batch is launched for you.
• Ensembles and Monte Carlo CPU ✓ GPU ✓ Many independent samples in one batched run.
• Divergent workloads CPU ✓ GPU ✓ Finished samples are compacted out, so each launch covers only the samples still running.
• Events and early exit CPU ✓ GPU ✓ A sample stops on its own condition and leaves the work.
• Adaptive ODEs, embedded pairs CPU ✓ GPU ✓ eagle.simulate runs an embedded RKF7(8) pair with per-sample step control.
• Deployment outside Python CPU ✓ GPU ✓ A compiled kernel is embedded in a C++ program and run there.
• Differentiable simulation into learning CPU ✓ GPU ✓ Gradients through a whole captured run.
• Ensemble data for training CPU ✓ GPU ✓ Simulated batches feed a PyTorch training loop without copies.
• Hybrid, physics-informed models CPU ✓ GPU ✓ A network and a physics model in one differentiable program.

Not first-class: Hand-tuned kernels, Half precision, Dense linear algebra, large solvers, Dense tensor training, Low-precision inference, Array-style programs.

• Hand-tuned kernels CPU ✓ GPU ✓ You write the per-thread kernel and choose its launch.
• Fixed-step ODEs CPU ✓ GPU ✓ A time-step loop inside a per-thread kernel.
• Differentiable sensitivities CPU ✓ GPU ✓ Reverse mode through wp.Tape over its kernels.
• Zero-copy hand-over (DLPack) CPU ✓ GPU ✓ Zero-copy views of PyTorch, JAX, CuPy and NumPy arrays, DLPack included.
• Per-sample models and RHS CPU ✓ GPU ✓ A per-thread kernel holds one sample's model; you index it by thread.
• Half precision CPU ✓ GPU ✓ float16 arrays and arithmetic.
• Dense linear algebra, large solvers CPU ✓ GPU ✓ Tile Cholesky and matrix multiply, plus iterative solvers in warp.optim.
• Ensembles and Monte Carlo CPU ✓ GPU ✓ Per-thread random numbers over a launch of many samples.
• Events and early exit CPU ✓ GPU – On the CPU a sample's loop breaks on its own condition and the work moves on.
• Differentiable simulation into learning CPU ✓ GPU ✓ Gradients through whole simulations with wp.Tape.
• Ensemble data for training CPU ✓ GPU ✓ Arrays hand over to PyTorch and JAX for training without copies.
• Hybrid, physics-informed models CPU ✓ GPU ✓ Warp kernels inside PyTorch autograd, next to a network.

Not first-class: Divergent workloads, Adaptive ODEs, embedded pairs, Deployment outside Python, Dense tensor training, Low-precision inference, Array-style programs.

• Hand-tuned kernels CPU – GPU ✓ Pallas writes custom kernels with block-level control.
• Fixed-step ODEs CPU ✓ GPU ✓ A step loop with lax.scan, batched with vmap.
• Differentiable sensitivities CPU ✓ GPU ✓ grad, jvp and vjp: forward and reverse mode.
• Zero-copy hand-over (DLPack) CPU ✓ GPU ✓ DLPack import and export.
• Per-sample models and RHS CPU ✓ GPU ✓ Write one sample's function; vmap batches it.
• Half precision CPU ✓ GPU ✓ bfloat16, float16 and float8 types.
• Dense linear algebra, large solvers CPU ✓ GPU ✓ jax.numpy.linalg and jax.scipy.linalg.
• Ensembles and Monte Carlo CPU ✓ GPU ✓ Batched sampling with explicit random keys.
• Deployment outside Python CPU ✓ GPU ✓ jax.export serialises a compiled program for other runtimes.
• Differentiable simulation into learning CPU ✓ GPU ✓ Gradients through a whole simulation loop.
• Ensemble data for training CPU ✓ GPU ✓ Generated arrays feed a JAX training loop directly.
• Hybrid, physics-informed models CPU ✓ GPU ✓ A network and a physics model in one function, differentiated together.
• Dense tensor training CPU ✓ GPU ✓ Training loops with grad and jit.
• Low-precision inference CPU ✓ GPU ✓ Low-precision types, bfloat16 and float8, for inference.
• Array-style programs CPU ✓ GPU ✓ The NumPy API, traced and compiled.

Not first-class: Divergent workloads, Events and early exit, Adaptive ODEs, embedded pairs.

• Fixed-step ODEs CPU ✓ GPU ✓ A whole batch of states stepped as tensors.
• Differentiable sensitivities CPU ✓ GPU ✓ Autograd, reverse and forward mode.
• Zero-copy hand-over (DLPack) CPU ✓ GPU ✓ DLPack import and export.
• Per-sample models and RHS CPU ✓ GPU ✓ Write one sample's function; torch.func.vmap batches it.
• Half precision CPU ✓ GPU ✓ Autocast to float16 and bfloat16 (bfloat16 on the CPU).
• Dense linear algebra, large solvers CPU ✓ GPU ✓ torch.linalg.
• Ensembles and Monte Carlo CPU ✓ GPU ✓ Batched tensors with seeded random generators.
• Deployment outside Python CPU ✓ GPU ✓ torch.export and ahead-of-time compilation run models from C++.
• Differentiable simulation into learning CPU ✓ GPU ✓ Gradients through a simulation written in tensors.
• Ensemble data for training CPU ✓ GPU ✓ Simulated arrays taken into training without copies.
• Hybrid, physics-informed models CPU ✓ GPU ✓ A network and a physics model in one autograd graph.
• Dense tensor training CPU ✓ GPU ✓ Modules, optimisers and training loops.
• Low-precision inference CPU ✓ GPU ✓ Quantised and low-precision inference.
• Array-style programs CPU ✓ GPU ✓ Eager tensor expressions.

Not first-class: Hand-tuned kernels, Divergent workloads, Events and early exit, Adaptive ODEs, embedded pairs.

• Fixed-step ODEs CPU – GPU ✓ A whole batch of states stepped as arrays.
• Zero-copy hand-over (DLPack) CPU – GPU ✓ DLPack and the CUDA array interface.
• Dense linear algebra, large solvers CPU – GPU ✓ cupy.linalg over the CUDA math libraries.
• Ensembles and Monte Carlo CPU – GPU ✓ Batched random sampling on the GPU.
• Ensemble data for training CPU – GPU ✓ Arrays hand over to PyTorch and JAX without copies.
• Array-style programs CPU – GPU ✓ The NumPy API on the GPU.

Not first-class: Hand-tuned kernels, Differentiable sensitivities, Per-sample models and RHS, Half precision, Divergent workloads, Events and early exit, Adaptive ODEs, embedded pairs, Deployment outside Python, Differentiable simulation into learning, Hybrid, physics-informed models, Dense tensor training, Low-precision inference.

• Hand-tuned kernels CPU ✓ GPU ✓ Compiled loops you control, run in parallel with prange. Thread indexing, shared memory and explicit launch shapes.
• Fixed-step ODEs CPU ✓ GPU ✓ A time-step loop compiled with njit, one sample per prange iteration. A time-step loop inside a kernel.
• Zero-copy hand-over (DLPack) CPU ✓ GPU ✓ Works on NumPy arrays directly, which other libraries read without copies. The CUDA array interface, read by CuPy, PyTorch and others.
• Per-sample models and RHS CPU ✓ GPU ✓ guvectorize: write one sample, batched for you.
• Half precision CPU – GPU ✓ float16 arithmetic in CUDA kernels.
• Dense linear algebra, large solvers CPU ✓ GPU – np.linalg calls inside compiled code, LAPACK underneath.
• Ensembles and Monte Carlo CPU ✓ GPU ✓ np.random inside compiled, parallel loops. Per-thread random number generators.
• Ensemble data for training CPU ✓ GPU ✓ Results are NumPy arrays, which training frameworks read without copies. Device arrays hand over without copies through the CUDA array interface.

Not first-class: Differentiable sensitivities, Divergent workloads, Events and early exit, Adaptive ODEs, embedded pairs, Deployment outside Python, Differentiable simulation into learning, Hybrid, physics-informed models, Dense tensor training, Low-precision inference, Array-style programs.

• Fixed-step ODEs CPU ✓ GPU – A whole batch of states stepped as arrays.
• Zero-copy hand-over (DLPack) CPU ✓ GPU – DLPack import, and arrays every library reads.
• Half precision CPU ✓ GPU – float16 storage and arithmetic.
• Dense linear algebra, large solvers CPU ✓ GPU – numpy.linalg over LAPACK.
• Ensembles and Monte Carlo CPU ✓ GPU – Batched random sampling.
• Ensemble data for training CPU ✓ GPU – Arrays hand over to training frameworks without copies.
• Array-style programs CPU ✓ GPU – Whole-array expressions are the model.

Not first-class: Hand-tuned kernels, Differentiable sensitivities, Per-sample models and RHS, Divergent workloads, Events and early exit, Adaptive ODEs, embedded pairs, Deployment outside Python, Differentiable simulation into learning, Hybrid, physics-informed models, Dense tensor training, Low-precision inference.