Two worlds on NVIDIA H100 80GB HBM3, card of 2026-10-13, script 02d7ded8.
| Block | Needs | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | covered | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | covered | – | – |
| Differentiable sensitivities | Derivatives | covered | covered | covered | covered |
| Zero-copy hand-over (DLPack) | Your arrays | covered | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – |
| Half precision | Half precision | – | – | covered | covered |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | – | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered |
| Array-style programs | Array style | – | – | covered | covered |
| Feature | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|
| Uneven ensembles | 613 µs (1.0× the best) ✓ | 1.54 ms (2.5× the best) | 47.0 ms (76× the best) | 84.5 ms (130× the best) |
| Regular ensembles | 1.75 ms (1.0× the best) ✓ | 1.71 ms (1.0× the best) ✓ | 48.1 ms (28× the best) | 83.6 ms (48× the best) |
| Small jobs | 103 µs (1.0× the best) ✓ | 112 µs (1.0× the best) ✓ | 21.8 ms (210× the best) | 65.7 ms (630× the best) |
| Adaptive ODEs | 43.6 ms (1.0× the best) ✓ | 101 ms (2.3× the best) | 1.11 s (25× the best) | 7.17 s (160× the best) |
| Early-finish saving | 82% (1.0× the best) ✓ | 12% (6.6× the best) | 2% (27× the best) | none (no saving) |
| Uneven-batch efficiency | 46% (1.0× the best) ✓ | 18% (2.5× the best) | <1% (76× the best) | <1% (130× the best) |
| Memory | 40 MiB (1.0× the best) ✓ | 62 MiB (1.5× the best) ✓ | 158 MiB (3.9× the best) | 242 MiB (6.0× the best) |
| Compile time | 2.48 s (1-10 s: noticeable) ✓ | 9.28 s (1-10 s: noticeable) | 4.22 s (1-10 s: noticeable) ✓ | 3.71 s (1-10 s: noticeable) ✓ |
| Code size | 32 lines (1.4× the best) ✓ | 40 lines (1.8× the best) ✓ | 29 lines (1.3× the best) ✓ | 22 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 3 of 5 Per-thread kernels are its home ground; it also offers matrix and tile types for dense blocks. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You write per-thread kernels; whole-array expressions are not the model. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 3 of 5 float16 support and tile operations that can use tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-thread kernel: you index and loop yourself, and choose the launch. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 4 of 5 ✓ Reverse mode through wp.Tape over its kernels, with its emphasis on reverse mode over the tape. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ You write the per-thread kernel and choose its launch: near-total control short of raw CUDA, the right choice for hand-tuned kernels. | 3 of 5 Pallas exposes kernel-level control; plain JAX leaves scheduling to XLA. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 4 of 5 ✓ Zero-copy views of PyTorch, JAX and NumPy arrays. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Kernels run inside Python; modules can be compiled ahead of time but need the Warp runtime. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 2 of 5 NVIDIA GPUs and the CPU; no public path to add a backend. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. |
Two worlds on NVIDIA L4, card of 2026-10-14, script 02d7ded8.
| Block | Needs | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | – | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | – | – | – |
| Differentiable sensitivities | Derivatives | covered | covered | covered | covered |
| Zero-copy hand-over (DLPack) | Your arrays | covered | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – |
| Half precision | Half precision | – | – | covered | covered |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | covered | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered |
| Array-style programs | Array style | – | – | covered | covered |
| Feature | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|
| Uneven ensembles | 25.3 ms (1.0× the best) ✓ | 105 ms (4.1× the best) | 243 ms (9.5× the best) | 251 ms (9.8× the best) |
| Regular ensembles | 103 ms (1.0× the best) ✓ | 119 ms (1.1× the best) ✓ | 242 ms (2.3× the best) | 251 ms (2.4× the best) |
| Small jobs | 441 µs (1.0× the best) ✓ | 1.64 ms (3.7× the best) | 17.6 ms (39× the best) | 64.3 ms (140× the best) |
| Adaptive ODEs | 2.32 s (1.0× the best) ✓ | 4.27 s (1.8× the best) ✓ | 7.27 s (3.1× the best) | 55.0 s (23× the best) |
| Early-finish saving | 96% (1.0× the best) ✓ | 15% (6.3× the best) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 79% (1.0× the best) ✓ | 19% (4.1× the best) | 8% (9.5× the best) | 8% (9.8× the best) |
| Memory | 40 MiB (1.0× the best) ✓ | 62 MiB (1.5× the best) ✓ | 134 MiB (3.3× the best) | 130 MiB (3.2× the best) |
| Compile time | 3.81 s (1-10 s: noticeable) ✓ | 12.3 s (10-60 s: long) | 4.68 s (1-10 s: noticeable) ✓ | 6.70 s (1-10 s: noticeable) ✓ |
| Code size | 32 lines (1.4× the best) ✓ | 40 lines (1.8× the best) ✓ | 29 lines (1.3× the best) ✓ | 22 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 3 of 5 Per-thread kernels are its home ground; it also offers matrix and tile types for dense blocks. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You write per-thread kernels; whole-array expressions are not the model. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 3 of 5 float16 support and tile operations that can use tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-thread kernel: you index and loop yourself, and choose the launch. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 4 of 5 ✓ Reverse mode through wp.Tape over its kernels, with its emphasis on reverse mode over the tape. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ You write the per-thread kernel and choose its launch: near-total control short of raw CUDA, the right choice for hand-tuned kernels. | 3 of 5 Pallas exposes kernel-level control; plain JAX leaves scheduling to XLA. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 4 of 5 ✓ Zero-copy views of PyTorch, JAX and NumPy arrays. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Kernels run inside Python; modules can be compiled ahead of time but need the Warp runtime. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 2 of 5 NVIDIA GPUs and the CPU; no public path to add a backend. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. |
Two worlds on NVIDIA A100-SXM4-40GB, card of 2026-10-13, script 02d7ded8.
| Block | Needs | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | covered | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | covered | – | – |
| Differentiable sensitivities | Derivatives | covered | covered | covered | covered |
| Zero-copy hand-over (DLPack) | Your arrays | covered | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – |
| Half precision | Half precision | – | – | covered | covered |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | – | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered |
| Array-style programs | Array style | – | – | covered | covered |
| Feature | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|
| Uneven ensembles | 1.50 ms (1.0× the best) ✓ | 5.94 ms (3.9× the best) | 90.7 ms (60× the best) | 167 ms (110× the best) |
| Regular ensembles | 4.85 ms (1.0× the best) ✓ | 6.67 ms (1.3× the best) ✓ | 90.5 ms (18× the best) | 166 ms (34× the best) |
| Small jobs | 156 µs (1.0× the best) ✓ | 272 µs (1.7× the best) ✓ | 28.3 ms (180× the best) | 79.1 ms (500× the best) |
| Adaptive ODEs | 107 ms (1.0× the best) ✓ | 218 ms (2.0× the best) | 2.19 s (20× the best) | 13.7 s (120× the best) |
| Early-finish saving | 88% (1.0× the best) ✓ | 13% (6.3× the best) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 65% (1.0× the best) ✓ | 16% (3.9× the best) | 1% (60× the best) | <1% (110× the best) |
| Memory | 40 MiB (1.0× the best) ✓ | 62 MiB (1.5× the best) ✓ | 134 MiB (3.3× the best) | 176 MiB (4.4× the best) |
| Compile time | 3.77 s (1-10 s: noticeable) ✓ | 11.9 s (10-60 s: long) | 6.14 s (1-10 s: noticeable) ✓ | 6.63 s (1-10 s: noticeable) ✓ |
| Code size | 32 lines (1.4× the best) ✓ | 40 lines (1.8× the best) ✓ | 29 lines (1.3× the best) ✓ | 22 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 3 of 5 Per-thread kernels are its home ground; it also offers matrix and tile types for dense blocks. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You write per-thread kernels; whole-array expressions are not the model. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 3 of 5 float16 support and tile operations that can use tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-thread kernel: you index and loop yourself, and choose the launch. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 4 of 5 ✓ Reverse mode through wp.Tape over its kernels, with its emphasis on reverse mode over the tape. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ You write the per-thread kernel and choose its launch: near-total control short of raw CUDA, the right choice for hand-tuned kernels. | 3 of 5 Pallas exposes kernel-level control; plain JAX leaves scheduling to XLA. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 4 of 5 ✓ Zero-copy views of PyTorch, JAX and NumPy arrays. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Kernels run inside Python; modules can be compiled ahead of time but need the Warp runtime. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 2 of 5 NVIDIA GPUs and the CPU; no public path to add a backend. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. |
Two worlds on Tesla T4, card of 2026-10-13, script 02d7ded8.
| Block | Needs | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | – | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | – | – | – |
| Differentiable sensitivities | Derivatives | covered | covered | covered | covered |
| Zero-copy hand-over (DLPack) | Your arrays | covered | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – |
| Half precision | Half precision | – | – | covered | covered |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | covered | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered |
| Array-style programs | Array style | – | – | covered | covered |
| Feature | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|
| Uneven ensembles | 46.1 ms (1.0× the best) ✓ | 194 ms (4.2× the best) | 613 ms (13× the best) | 530 ms (11× the best) |
| Regular ensembles | 191 ms (1.0× the best) ✓ | 220 ms (1.1× the best) ✓ | 610 ms (3.1× the best) | 532 ms (2.7× the best) |
| Small jobs | 526 µs (1.0× the best) ✓ | 2.10 ms (3.9× the best) | 26.6 ms (50× the best) | 89.6 ms (170× the best) |
| Adaptive ODEs | 4.26 s (1.0× the best) ✓ | 7.88 s (1.8× the best) ✓ | 13.1 s (3.0× the best) | 95.1 s (22× the best) |
| Early-finish saving | 96% (1.0× the best) ✓ | 15% (6.4× the best) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 81% (1.0× the best) ✓ | 19% (4.2× the best) | 6% (13× the best) | 7% (11× the best) |
| Memory | 40 MiB (1.0× the best) ✓ | 62 MiB (1.5× the best) ✓ | 136 MiB (3.4× the best) | 116 MiB (2.9× the best) |
| Compile time | 4.85 s (1-10 s: noticeable) ✓ | 12.7 s (10-60 s: long) | 4.82 s (1-10 s: noticeable) ✓ | 6.85 s (1-10 s: noticeable) ✓ |
| Code size | 32 lines (1.4× the best) ✓ | 40 lines (1.8× the best) ✓ | 29 lines (1.3× the best) ✓ | 22 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 3 of 5 Per-thread kernels are its home ground; it also offers matrix and tile types for dense blocks. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You write per-thread kernels; whole-array expressions are not the model. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 3 of 5 float16 support and tile operations that can use tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-thread kernel: you index and loop yourself, and choose the launch. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 4 of 5 ✓ Reverse mode through wp.Tape over its kernels, with its emphasis on reverse mode over the tape. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ You write the per-thread kernel and choose its launch: near-total control short of raw CUDA, the right choice for hand-tuned kernels. | 3 of 5 Pallas exposes kernel-level control; plain JAX leaves scheduling to XLA. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 4 of 5 ✓ Zero-copy views of PyTorch, JAX and NumPy arrays. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Kernels run inside Python; modules can be compiled ahead of time but need the Warp runtime. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 2 of 5 NVIDIA GPUs and the CPU; no public path to add a backend. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. |
Two worlds on Quadro P2000, card of 2026-10-13, script 02d7ded8.
| Block | Needs | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | covered | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | covered | – | – |
| Differentiable sensitivities | Derivatives | covered | covered | covered | covered |
| Zero-copy hand-over (DLPack) | Your arrays | covered | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – |
| Half precision | Half precision | – | – | covered | covered |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | covered | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered |
| Array-style programs | Array style | – | – | covered | covered |
| Feature | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|
| Uneven ensembles | 150 ms (1.0× the best) ✓ | 615 ms (4.1× the best) | 1.37 s (9.1× the best) | 7.40 s (49× the best) |
| Regular ensembles | 640 ms (1.0× the best) ✓ | 699 ms (1.0× the best) ✓ | 1.37 s (2.1× the best) | 7.42 s (11× the best) |
| Small jobs | 822 µs (1.0× the best) ✓ | 1.41 ms (1.7× the best) ✓ | 17.9 ms (21× the best) | 112 ms (130× the best) |
| Adaptive ODEs | 13.4 s (1.0× the best) ✓ | 26.3 s (1.9× the best) ✓ | 40.1 s (2.9× the best) | 184 s (13× the best) |
| Early-finish saving | 97% (1.0× the best) ✓ | 15% (6.4× the best) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 92% (1.0× the best) ✓ | 22% (4.1× the best) | 10% (9.1× the best) | 1% (49× the best) |
| Memory | 40 MiB (1.0× the best) ✓ | 62 MiB (1.5× the best) ✓ | 136 MiB (3.4× the best) | 264 MiB (6.6× the best) |
| Compile time | 4.48 s (1-10 s: noticeable) ✓ | 9.35 s (1-10 s: noticeable) | 4.26 s (1-10 s: noticeable) ✓ | no reading |
| Code size | 32 lines (1.4× the best) ✓ | 40 lines (1.8× the best) ✓ | 29 lines (1.3× the best) ✓ | 22 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 3 of 5 Per-thread kernels are its home ground; it also offers matrix and tile types for dense blocks. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You write per-thread kernels; whole-array expressions are not the model. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 3 of 5 float16 support and tile operations that can use tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-thread kernel: you index and loop yourself, and choose the launch. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 4 of 5 ✓ Reverse mode through wp.Tape over its kernels, with its emphasis on reverse mode over the tape. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ You write the per-thread kernel and choose its launch: near-total control short of raw CUDA, the right choice for hand-tuned kernels. | 3 of 5 Pallas exposes kernel-level control; plain JAX leaves scheduling to XLA. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 4 of 5 ✓ Zero-copy views of PyTorch, JAX and NumPy arrays. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Kernels run inside Python; modules can be compiled ahead of time but need the Warp runtime. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 2 of 5 NVIDIA GPUs and the CPU; no public path to add a backend. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. |
Two worlds on NVIDIA RTX PRO 6000 Blackwell Server Edition, card of 2026-10-14, script 02d7ded8.
| Block | Needs | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | – | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | – | – | – |
| Differentiable sensitivities | Derivatives | covered | covered | covered | covered |
| Zero-copy hand-over (DLPack) | Your arrays | covered | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – |
| Half precision | Half precision | – | – | covered | covered |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | covered | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered |
| Array-style programs | Array style | – | – | covered | covered |
| Feature | raptor | NVIDIA Warp | JAX | PyTorch |
|---|---|---|---|---|
| Uneven ensembles | 7.41 ms (1.0× the best) ✓ | 28.9 ms (3.8× the best) | 79.5 ms (10× the best) | 72.4 ms (9.7× the best) |
| Regular ensembles | 27.6 ms (1.0× the best) ✓ | 32.1 ms (1.1× the best) ✓ | 79.5 ms (2.8× the best) | 71.6 ms (2.5× the best) |
| Small jobs | 634 µs (1.0× the best) ✓ | 1.43 ms (2.2× the best) | 14.6 ms (23× the best) | 36.9 ms (58× the best) |
| Adaptive ODEs | 607 ms (1.0× the best) ✓ | 1.12 s (1.8× the best) ✓ | 2.79 s (4.5× the best) | 8.55 s (14× the best) |
| Early-finish saving | 93% (1.0× the best) ✓ | 12% (7.2× the best) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 70% (1.0× the best) ✓ | 18% (3.8× the best) | 6% (10× the best) | 7% (9.7× the best) |
| Memory | 40 MiB (1.0× the best) ✓ | 62 MiB (1.5× the best) ✓ | 158 MiB (3.9× the best) | 240 MiB (6.0× the best) |
| Compile time | 1.72 s (1-10 s: noticeable) ✓ | 4.38 s (1-10 s: noticeable) | 2.78 s (1-10 s: noticeable) ✓ | 2.66 s (1-10 s: noticeable) ✓ |
| Code size | 32 lines (1.4× the best) ✓ | 40 lines (1.8× the best) ✓ | 29 lines (1.3× the best) ✓ | 22 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 3 of 5 Per-thread kernels are its home ground; it also offers matrix and tile types for dense blocks. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You write per-thread kernels; whole-array expressions are not the model. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 3 of 5 float16 support and tile operations that can use tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-thread kernel: you index and loop yourself, and choose the launch. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 4 of 5 ✓ Reverse mode through wp.Tape over its kernels, with its emphasis on reverse mode over the tape. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ You write the per-thread kernel and choose its launch: near-total control short of raw CUDA, the right choice for hand-tuned kernels. | 3 of 5 Pallas exposes kernel-level control; plain JAX leaves scheduling to XLA. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 4 of 5 ✓ Zero-copy views of PyTorch, JAX and NumPy arrays. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Kernels run inside Python; modules can be compiled ahead of time but need the Warp runtime. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 2 of 5 NVIDIA GPUs and the CPU; no public path to add a backend. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. |
Two worlds, drawn as soft regions that blend where they meet; the blend is the boundary. A block of work is covered by a tool when the tool covers every feature the block needs: within 2× of the best tool on this device for a measured feature, 4 of 5 for a rubric one (italic: the author's judgement). Same rule for every tool; a dashed block is one no tool covers on this device. A tool's shape is the rounded convex hull of the blocks it covers and never encloses a block it does not cover (where one hull would, the tool is drawn in two or more pieces). Arrays cross zero-copy between raptor and CuPy, PyTorch, NVIDIA Warp and NumPy today, not JAX. The tools are complementary; overlap is not a ranking.
Radar for NVIDIA H100 80GB HBM3, card of 2026-10-13, script 02d7ded8. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | NVIDIA Warp | JAX | PyTorch | CuPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.94 of the radius (mean of 4) | 0.49 of the radius (mean of 4) | 0.35 of the radius (mean of 4) | 0.20 of the radius (mean of 4) |
| Uneven ensembles | 613 µs (1.0× the best) | 1.54 ms (2.5× the best) | 47.0 ms (76× the best) | 84.5 ms (130× the best) | 368 ms (600× the best) |
| Regular ensembles | 1.75 ms (1.0× the best) | 1.71 ms (1.0× the best) | 48.1 ms (28× the best) | 83.6 ms (48× the best) | 365 ms (210× the best) |
| Small jobs | 103 µs (1.0× the best) | 112 µs (1.0× the best) | 21.8 ms (210× the best) | 65.7 ms (630× the best) | 352 ms (3400× the best) |
| Adaptive ODEs | 43.6 ms (1.0× the best) | 101 ms (2.3× the best) | 1.11 s (25× the best) | 7.17 s (160× the best) | 9.06 s (200× the best) |
| Footprint and turnaround | 0.80 of the radius (mean of 3) | 0.65 of the radius (mean of 3) | 0.60 of the radius (mean of 3) | 0.59 of the radius (mean of 3) | 0.57 of the radius (mean of 3) |
| Memory | 40 MiB (1.0× the best) | 62 MiB (1.5× the best) | 158 MiB (3.9× the best) | 242 MiB (6.0× the best) | 192 MiB (4.8× the best) |
| Compile time | 2.48 s (1-10 s: noticeable) | 9.28 s (1-10 s: noticeable) | 4.22 s (1-10 s: noticeable) | 3.71 s (1-10 s: noticeable) | 2.58 s (1-10 s: noticeable) |
| Code size | 32 lines (1.4× the best) | 40 lines (1.8× the best) | 29 lines (1.3× the best) | 22 lines (1.0× the best) | 32 lines (1.4× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.7 of 5 | 4.7 of 5 | 5.0 of 5 | 4.0 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 3 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 3.5 of 5 | 4.5 of 5 | 3.5 of 5 | 1.5 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 2 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 4 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 3.0 of 5 | 2.0 of 5 | 3.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 4 of 5 | 4 of 5 | 4 of 5 | 5 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 2 of 5 |
Radar for NVIDIA L4, card of 2026-10-14, script 02d7ded8. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | NVIDIA Warp | JAX | PyTorch | CuPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.85 of the radius (mean of 4) | 0.66 of the radius (mean of 4) | 0.49 of the radius (mean of 4) | 0.20 of the radius (mean of 4) |
| Uneven ensembles | 25.3 ms (1.0× the best) | 105 ms (4.1× the best) | 243 ms (9.5× the best) | 251 ms (9.8× the best) | 1.60 s (63× the best) |
| Regular ensembles | 103 ms (1.0× the best) | 119 ms (1.1× the best) | 242 ms (2.3× the best) | 251 ms (2.4× the best) | 1.60 s (15× the best) |
| Small jobs | 441 µs (1.0× the best) | 1.64 ms (3.7× the best) | 17.6 ms (39× the best) | 64.3 ms (140× the best) | 656 ms (1400× the best) |
| Adaptive ODEs | 2.32 s (1.0× the best) | 4.27 s (1.8× the best) | 7.27 s (3.1× the best) | 55.0 s (23× the best) | 52.8 s (22× the best) |
| Footprint and turnaround | 0.79 of the radius (mean of 3) | 0.62 of the radius (mean of 3) | 0.59 of the radius (mean of 3) | 0.64 of the radius (mean of 3) | 0.52 of the radius (mean of 3) |
| Memory | 40 MiB (1.0× the best) | 62 MiB (1.5× the best) | 134 MiB (3.3× the best) | 130 MiB (3.2× the best) | 192 MiB (4.8× the best) |
| Compile time | 3.81 s (1-10 s: noticeable) | 12.3 s (10-60 s: long) | 4.68 s (1-10 s: noticeable) | 6.70 s (1-10 s: noticeable) | 4.03 s (1-10 s: noticeable) |
| Code size | 32 lines (1.4× the best) | 40 lines (1.8× the best) | 29 lines (1.3× the best) | 22 lines (1.0× the best) | 32 lines (1.4× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.7 of 5 | 4.7 of 5 | 5.0 of 5 | 4.0 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 3 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 3.5 of 5 | 4.5 of 5 | 3.5 of 5 | 1.5 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 2 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 4 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 3.0 of 5 | 2.0 of 5 | 3.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 4 of 5 | 4 of 5 | 4 of 5 | 5 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 2 of 5 |
Radar for NVIDIA A100-SXM4-40GB, card of 2026-10-13, script 02d7ded8. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | NVIDIA Warp | JAX | PyTorch | CuPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.90 of the radius (mean of 4) | 0.50 of the radius (mean of 4) | 0.36 of the radius (mean of 4) | 0.20 of the radius (mean of 4) |
| Uneven ensembles | 1.50 ms (1.0× the best) | 5.94 ms (3.9× the best) | 90.7 ms (60× the best) | 167 ms (110× the best) | 673 ms (440× the best) |
| Regular ensembles | 4.85 ms (1.0× the best) | 6.67 ms (1.3× the best) | 90.5 ms (18× the best) | 166 ms (34× the best) | 679 ms (140× the best) |
| Small jobs | 156 µs (1.0× the best) | 272 µs (1.7× the best) | 28.3 ms (180× the best) | 79.1 ms (500× the best) | 673 ms (4300× the best) |
| Adaptive ODEs | 107 ms (1.0× the best) | 218 ms (2.0× the best) | 2.19 s (20× the best) | 13.7 s (120× the best) | 15.4 s (140× the best) |
| Footprint and turnaround | 0.79 of the radius (mean of 3) | 0.63 of the radius (mean of 3) | 0.58 of the radius (mean of 3) | 0.59 of the radius (mean of 3) | 0.52 of the radius (mean of 3) |
| Memory | 40 MiB (1.0× the best) | 62 MiB (1.5× the best) | 134 MiB (3.3× the best) | 176 MiB (4.4× the best) | 192 MiB (4.8× the best) |
| Compile time | 3.77 s (1-10 s: noticeable) | 11.9 s (10-60 s: long) | 6.14 s (1-10 s: noticeable) | 6.63 s (1-10 s: noticeable) | 4.05 s (1-10 s: noticeable) |
| Code size | 32 lines (1.4× the best) | 40 lines (1.8× the best) | 29 lines (1.3× the best) | 22 lines (1.0× the best) | 32 lines (1.4× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.7 of 5 | 4.7 of 5 | 5.0 of 5 | 4.0 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 3 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 3.5 of 5 | 4.5 of 5 | 3.5 of 5 | 1.5 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 2 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 4 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 3.0 of 5 | 2.0 of 5 | 3.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 4 of 5 | 4 of 5 | 4 of 5 | 5 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 2 of 5 |
Radar for Tesla T4, card of 2026-10-13, script 02d7ded8. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | NVIDIA Warp | JAX | PyTorch | CuPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.85 of the radius (mean of 4) | 0.62 of the radius (mean of 4) | 0.48 of the radius (mean of 4) | 0.20 of the radius (mean of 4) |
| Uneven ensembles | 46.1 ms (1.0× the best) | 194 ms (4.2× the best) | 613 ms (13× the best) | 530 ms (11× the best) | 3.70 s (80× the best) |
| Regular ensembles | 191 ms (1.0× the best) | 220 ms (1.1× the best) | 610 ms (3.1× the best) | 532 ms (2.7× the best) | 3.69 s (19× the best) |
| Small jobs | 526 µs (1.0× the best) | 2.10 ms (3.9× the best) | 26.6 ms (50× the best) | 89.6 ms (170× the best) | 666 ms (1200× the best) |
| Adaptive ODEs | 4.26 s (1.0× the best) | 7.88 s (1.8× the best) | 13.1 s (3.0× the best) | 95.1 s (22× the best) | 89.9 s (21× the best) |
| Footprint and turnaround | 0.78 of the radius (mean of 3) | 0.62 of the radius (mean of 3) | 0.59 of the radius (mean of 3) | 0.66 of the radius (mean of 3) | 0.51 of the radius (mean of 3) |
| Memory | 40 MiB (1.0× the best) | 62 MiB (1.5× the best) | 136 MiB (3.4× the best) | 116 MiB (2.9× the best) | 192 MiB (4.8× the best) |
| Compile time | 4.85 s (1-10 s: noticeable) | 12.7 s (10-60 s: long) | 4.82 s (1-10 s: noticeable) | 6.85 s (1-10 s: noticeable) | 4.43 s (1-10 s: noticeable) |
| Code size | 32 lines (1.4× the best) | 40 lines (1.8× the best) | 29 lines (1.3× the best) | 22 lines (1.0× the best) | 32 lines (1.4× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.7 of 5 | 4.7 of 5 | 5.0 of 5 | 4.0 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 3 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 3.5 of 5 | 4.5 of 5 | 3.5 of 5 | 1.5 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 2 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 4 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 3.0 of 5 | 2.0 of 5 | 3.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 4 of 5 | 4 of 5 | 4 of 5 | 5 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 2 of 5 |
Radar for Quadro P2000, card of 2026-10-13, script 02d7ded8. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | NVIDIA Warp | JAX | PyTorch | CuPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.85 of the radius (mean of 4) | 0.64 of the radius (mean of 4) | 0.24 of the radius (mean of 4) | 0.20 of the radius (mean of 4) |
| Uneven ensembles | 150 ms (1.0× the best) | 615 ms (4.1× the best) | 1.37 s (9.1× the best) | 7.40 s (49× the best) | 7.38 s (49× the best) |
| Regular ensembles | 640 ms (1.0× the best) | 699 ms (1.0× the best) | 1.37 s (2.1× the best) | 7.42 s (11× the best) | 7.41 s (11× the best) |
| Small jobs | 822 µs (1.0× the best) | 1.41 ms (1.7× the best) | 17.9 ms (21× the best) | 112 ms (130× the best) | 376 ms (450× the best) |
| Adaptive ODEs | 13.4 s (1.0× the best) | 26.3 s (1.9× the best) | 40.1 s (2.9× the best) | 184 s (13× the best) | 182 s (13× the best) |
| Footprint and turnaround | 0.78 of the radius (mean of 3) | 0.65 of the radius (mean of 3) | 0.63 of the radius (mean of 3) | 0.60 of the radius (mean of 2 of 3) | 0.56 of the radius (mean of 3) |
| Memory | 40 MiB (1.0× the best) | 62 MiB (1.5× the best) | 136 MiB (3.4× the best) | 264 MiB (6.6× the best) | 192 MiB (4.8× the best) |
| Compile time | 4.48 s (1-10 s: noticeable) | 9.35 s (1-10 s: noticeable) | 4.26 s (1-10 s: noticeable) | – | 4.04 s (1-10 s: noticeable) |
| Code size | 32 lines (1.4× the best) | 40 lines (1.8× the best) | 29 lines (1.3× the best) | 22 lines (1.0× the best) | 32 lines (1.4× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.7 of 5 | 4.7 of 5 | 5.0 of 5 | 4.0 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 3 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 3.5 of 5 | 4.5 of 5 | 3.5 of 5 | 1.5 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 2 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 4 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 3.0 of 5 | 2.0 of 5 | 3.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 4 of 5 | 4 of 5 | 4 of 5 | 5 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 2 of 5 |
Radar for NVIDIA RTX PRO 6000 Blackwell Server Edition, card of 2026-10-14, script 02d7ded8. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | NVIDIA Warp | JAX | PyTorch | CuPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.84 of the radius (mean of 4) | 0.56 of the radius (mean of 4) | 0.46 of the radius (mean of 4) | 0.20 of the radius (mean of 4) |
| Uneven ensembles | 7.41 ms (1.0× the best) | 28.9 ms (3.8× the best) | 79.5 ms (10× the best) | 72.4 ms (9.7× the best) | 300 ms (40× the best) |
| Regular ensembles | 27.6 ms (1.0× the best) | 32.1 ms (1.1× the best) | 79.5 ms (2.8× the best) | 71.6 ms (2.5× the best) | 296 ms (10× the best) |
| Small jobs | 634 µs (1.0× the best) | 1.43 ms (2.2× the best) | 14.6 ms (23× the best) | 36.9 ms (58× the best) | 229 ms (360× the best) |
| Adaptive ODEs | 607 ms (1.0× the best) | 1.12 s (1.8× the best) | 2.79 s (4.5× the best) | 8.55 s (14× the best) | 9.31 s (15× the best) |
| Footprint and turnaround | 0.82 of the radius (mean of 3) | 0.67 of the radius (mean of 3) | 0.61 of the radius (mean of 3) | 0.61 of the radius (mean of 3) | 0.58 of the radius (mean of 3) |
| Memory | 40 MiB (1.0× the best) | 62 MiB (1.5× the best) | 158 MiB (3.9× the best) | 240 MiB (6.0× the best) | 192 MiB (4.8× the best) |
| Compile time | 1.72 s (1-10 s: noticeable) | 4.38 s (1-10 s: noticeable) | 2.78 s (1-10 s: noticeable) | 2.66 s (1-10 s: noticeable) | 1.82 s (1-10 s: noticeable) |
| Code size | 32 lines (1.4× the best) | 40 lines (1.8× the best) | 29 lines (1.3× the best) | 22 lines (1.0× the best) | 32 lines (1.4× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.7 of 5 | 4.7 of 5 | 5.0 of 5 | 4.0 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 3 of 5 | 5 of 5 | 5 of 5 | 3 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 3.5 of 5 | 4.5 of 5 | 3.5 of 5 | 1.5 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 2 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 4 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 3.0 of 5 | 2.0 of 5 | 3.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 4 of 5 | 4 of 5 | 4 of 5 | 5 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 2 of 5 |
Every measured axis is the per-sample ensemble workload raptor is built for; dense tensor maths, training and half precision are the qualitative axes, where PyTorch and JAX lead. Outer is better; overlaps are complementary, not a ranking.
NVIDIA Warp gives you near-total control of every kernel, short of raw CUDA. raptor hands that control to the engine on purpose, so compaction and the launch shape are decided at run time; the two are different trade-offs, not a ranking.
Each of the six majors is the plain mean of its minor axes (the detailed radar draws every minor), with equal weights and the same rule for every tool; a minor a tool has no reading on is left out of its mean and the major's marker is drawn hollow. Hover or tap a major to see its minors.
Each measured axis is stretched over its own best-to-worst range, so ring labels differ per axis (compile time: fixed, 0.1 s to 100 s; code size: at least 4x). Axes are grouped by theme, so read the axes, not the area.
Italic axes are the author's judgement, not measurements: hollow markers, a linear scale, and no marker where a tool has no reading. A hollow marker on a measured axis means a minor is missing or, for compile time, is the tool's simple-kernel time. The hover panel has each axis's full wording.
Two worlds on AMD EPYC 9B45, card of 2026-10-13, script cb2eb627.
| Block | Needs | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | – | – | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | – | – | – | – |
| Differentiable sensitivities | Derivatives | covered | – | covered | covered | – |
| Zero-copy hand-over (DLPack) | Your arrays | covered | – | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – | – |
| Half precision | Half precision | – | – | covered | covered | – |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | – | – | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | – | – | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | – | – | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered | – |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered | – |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered | – |
| Array-style programs | Array style | – | – | covered | covered | covered |
| Feature | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Uneven ensembles | 142 ms (1.0× the best) ✓ | 328 ms (2.3× the best) | 1.86 s (13× the best) | 10.2 s (72× the best) | 7.72 s (54× the best) |
| Regular ensembles | 187 ms (1.0× the best) ✓ | 1.53 s (8.1× the best) | 1.94 s (10× the best) | 10.2 s (54× the best) | 7.65 s (40× the best) |
| Small jobs | 167 µs (1.0× the best) ✓ | 368 µs (2.1× the best) | 491 µs (2.9× the best) | 44.7 ms (260× the best) | 15.6 ms (92× the best) |
| Adaptive ODEs | 3.76 s (1.0× the best) ✓ | 19.9 s (5.3× the best) | 60.5 s (16× the best) | no reading | no reading |
| Early-finish saving | 30% (3.2× the best) | 100% (1.0× the best) ✓ | 5% (19× the best) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 6% (1.0× the best) ✓ | 2% (2.3× the best) | <1% (13× the best) | <1% (72× the best) | <1% (100× the best) |
| Memory | 61.5 MiB (1.0× the best) ✓ | 68.4 MiB (1.1× the best) ✓ | 174 MiB (2.8× the best) | 275 MiB (4.4× the best) | 169 MiB (2.7× the best) |
| Compile time | 565 ms (under 1 s: instant) | 449 ms (under 1 s: instant) | 71.5 ms (under 1 s: instant) ✓ | no reading | no compile step (nothing to compile) ✓ |
| Code size | 28 lines (1.1× the best) ✓ | 42 lines (1.7× the best) ✓ | 25 lines (1.0× the best) ✓ | 25 lines (1.0× the best) ✓ | 24 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 2 of 5 Compiles loops and NumPy-style code; dense linear algebra comes from the libraries it calls. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. | 4 of 5 ✓ The reference API for dense array maths and broadcasting on the CPU, with tuned BLAS and LAPACK underneath. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You mostly write loops over arrays; array expressions are secondary. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. | 5 of 5 ✓ The whole-array expression is the programming model, evaluated eagerly; the right choice for array code on the CPU. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 2 of 5 float16 arithmetic intrinsics in numba.cuda; no BF16/FP8 or tensor-core path. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. | 2 of 5 float16 storage and arithmetic, but slow on the CPU and nothing below it. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-index body under prange or cuda.jit; indexing and launch are yours. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. | 1 of 5 Whole-array code; there is no per-sample model. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 1 of 5 No automatic differentiation of its own. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. | 1 of 5 No automatic differentiation of its own. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ prange, explicit threads and typed loops; SIMD and memory layout are yours. | 2 of 5 Plain JAX leaves threads, vectorisation and layout to XLA; Pallas control is aimed at the GPU. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. | 2 of 5 Strides and memory layout are yours to choose; threads and SIMD are left to the libraries underneath. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 3 of 5 Reads NumPy arrays directly and exposes the CUDA array interface; wider exchange takes some glue. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. | 4 of 5 ✓ The array protocols everyone reads, on the host; device memory is out of its scope. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Ahead-of-time compilation exists in a limited form; most use stays inside Python. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. | 1 of 5 A Python library; nothing is compiled into a separate artefact. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 3 of 5 An extension API for new types and targets, at a low level. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. | 3 of 5 Array-API dispatch lets other array libraries stand in. |
Two worlds on AMD EPYC 7B13, card of 2026-10-13, script cb2eb627.
| Block | Needs | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | – | – | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | – | – | – | – |
| Differentiable sensitivities | Derivatives | covered | – | covered | covered | – |
| Zero-copy hand-over (DLPack) | Your arrays | covered | – | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – | – |
| Half precision | Half precision | – | – | covered | covered | – |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | covered | – | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered | – |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered | – |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered | – |
| Array-style programs | Array style | – | – | covered | covered | covered |
| Feature | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Uneven ensembles | 400 ms (1.0× the best) ✓ | 398 ms (1.0× the best) ✓ | 2.15 s (5.3× the best) | 8.19 s (20× the best) | 4.07 s (10× the best) |
| Regular ensembles | 693 ms (1.0× the best) ✓ | 1.85 s (2.6× the best) | 2.14 s (3.0× the best) | 8.37 s (12× the best) | 4.04 s (5.8× the best) |
| Small jobs | 498 µs (1.1× the best) ✓ | 448 µs (1.0× the best) ✓ | 847 µs (1.8× the best) ✓ | 74.9 ms (160× the best) | 39.5 ms (88× the best) |
| Adaptive ODEs | 26.2 s (1.0× the best) ✓ | 31.9 s (1.2× the best) ✓ | 62.2 s (2.3× the best) | no reading | no reading |
| Early-finish saving | 53% (1.8× the best) ✓ | 100% (1.0× the best) ✓ | none (no saving) | 2% (35× the best) | none (no saving) |
| Uneven-batch efficiency | 5% (1.0× the best) ✓ | 5% (1.0× the best) ✓ | <1% (5.3× the best) | <1% (20× the best) | <1% (54× the best) |
| Memory | 61.6 MiB (1.0× the best) ✓ | 68.2 MiB (1.1× the best) ✓ | 182 MiB (2.9× the best) | 275 MiB (4.4× the best) | 169 MiB (2.7× the best) |
| Compile time | 1.10 s (1-10 s: noticeable) | 712 ms (under 1 s: instant) | 123 ms (under 1 s: instant) ✓ | no reading | no compile step (nothing to compile) ✓ |
| Code size | 28 lines (1.1× the best) ✓ | 42 lines (1.7× the best) ✓ | 25 lines (1.0× the best) ✓ | 25 lines (1.0× the best) ✓ | 24 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 2 of 5 Compiles loops and NumPy-style code; dense linear algebra comes from the libraries it calls. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. | 4 of 5 ✓ The reference API for dense array maths and broadcasting on the CPU, with tuned BLAS and LAPACK underneath. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You mostly write loops over arrays; array expressions are secondary. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. | 5 of 5 ✓ The whole-array expression is the programming model, evaluated eagerly; the right choice for array code on the CPU. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 2 of 5 float16 arithmetic intrinsics in numba.cuda; no BF16/FP8 or tensor-core path. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. | 2 of 5 float16 storage and arithmetic, but slow on the CPU and nothing below it. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-index body under prange or cuda.jit; indexing and launch are yours. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. | 1 of 5 Whole-array code; there is no per-sample model. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 1 of 5 No automatic differentiation of its own. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. | 1 of 5 No automatic differentiation of its own. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ prange, explicit threads and typed loops; SIMD and memory layout are yours. | 2 of 5 Plain JAX leaves threads, vectorisation and layout to XLA; Pallas control is aimed at the GPU. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. | 2 of 5 Strides and memory layout are yours to choose; threads and SIMD are left to the libraries underneath. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 3 of 5 Reads NumPy arrays directly and exposes the CUDA array interface; wider exchange takes some glue. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. | 4 of 5 ✓ The array protocols everyone reads, on the host; device memory is out of its scope. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Ahead-of-time compilation exists in a limited form; most use stays inside Python. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. | 1 of 5 A Python library; nothing is compiled into a separate artefact. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 3 of 5 An extension API for new types and targets, at a low level. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. | 3 of 5 Array-API dispatch lets other array libraries stand in. |
Two worlds on Google Axion (Arm Neoverse-V2), card of 2026-10-13, script cb2eb627.
| Block | Needs | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | – | – | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | – | covered | – | – |
| Differentiable sensitivities | Derivatives | covered | – | covered | covered | – |
| Zero-copy hand-over (DLPack) | Your arrays | covered | – | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – | – |
| Half precision | Half precision | – | – | covered | covered | – |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | covered | covered | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | covered | – | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | covered | covered | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered | – |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | covered | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | covered | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered | – |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered | – |
| Array-style programs | Array style | – | – | covered | covered | covered |
| Feature | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Uneven ensembles | 301 ms (1.0× the best) ✓ | 388 ms (1.2× the best) ✓ | 410 ms (1.3× the best) ✓ | 3.02 s (10× the best) | 2.22 s (7.3× the best) |
| Regular ensembles | 648 ms (1.5× the best) ✓ | 1.80 s (4.3× the best) | 411 ms (1.0× the best) ✓ | 2.76 s (6.7× the best) | 2.20 s (5.3× the best) |
| Small jobs | 407 µs (1.0× the best) ✓ | 438 µs (1.0× the best) ✓ | 803 µs (1.9× the best) ✓ | 62.9 ms (150× the best) | 16.9 ms (41× the best) |
| Adaptive ODEs | 13.3 s (1.0× the best) ✓ | 22.5 s (1.6× the best) ✓ | 41.6 s (3.1× the best) | no reading | no reading |
| Early-finish saving | 62% (1.6× the best) ✓ | 100% (1.0× the best) ✓ | none (no saving) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 7% (1.0× the best) ✓ | 6% (1.1× the best) ✓ | 6% (1.2× the best) ✓ | <1% (9.1× the best) | <1% (49× the best) |
| Memory | 61.8 MiB (1.0× the best) ✓ | 67.6 MiB (1.0× the best) ✓ | 182 MiB (2.9× the best) | 217 MiB (3.5× the best) | 169 MiB (2.7× the best) |
| Compile time | 297 ms (under 1 s: instant) | 520 ms (under 1 s: instant) | 83.7 ms (under 1 s: instant) ✓ | no reading | no compile step (nothing to compile) ✓ |
| Code size | 28 lines (1.1× the best) ✓ | 42 lines (1.7× the best) ✓ | 25 lines (1.0× the best) ✓ | 25 lines (1.0× the best) ✓ | 24 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 2 of 5 Compiles loops and NumPy-style code; dense linear algebra comes from the libraries it calls. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. | 4 of 5 ✓ The reference API for dense array maths and broadcasting on the CPU, with tuned BLAS and LAPACK underneath. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You mostly write loops over arrays; array expressions are secondary. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. | 5 of 5 ✓ The whole-array expression is the programming model, evaluated eagerly; the right choice for array code on the CPU. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 2 of 5 float16 arithmetic intrinsics in numba.cuda; no BF16/FP8 or tensor-core path. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. | 2 of 5 float16 storage and arithmetic, but slow on the CPU and nothing below it. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-index body under prange or cuda.jit; indexing and launch are yours. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. | 1 of 5 Whole-array code; there is no per-sample model. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 1 of 5 No automatic differentiation of its own. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. | 1 of 5 No automatic differentiation of its own. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ prange, explicit threads and typed loops; SIMD and memory layout are yours. | 2 of 5 Plain JAX leaves threads, vectorisation and layout to XLA; Pallas control is aimed at the GPU. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. | 2 of 5 Strides and memory layout are yours to choose; threads and SIMD are left to the libraries underneath. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 3 of 5 Reads NumPy arrays directly and exposes the CUDA array interface; wider exchange takes some glue. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. | 4 of 5 ✓ The array protocols everyone reads, on the host; device memory is out of its scope. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Ahead-of-time compilation exists in a limited form; most use stays inside Python. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. | 1 of 5 A Python library; nothing is compiled into a separate artefact. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 3 of 5 An extension API for new types and targets, at a low level. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. | 3 of 5 Array-API dispatch lets other array libraries stand in. |
Two worlds on Intel Xeon Platinum 8581C, card of 2026-10-13, script cb2eb627.
| Block | Needs | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|---|
| Hand-tuned kernels | Control, Regular ensembles, Small jobs | – | – | – | – | – |
| Fixed-step ODEs | Regular ensembles, Small jobs | covered | – | – | – | – |
| Differentiable sensitivities | Derivatives | covered | – | covered | covered | – |
| Zero-copy hand-over (DLPack) | Your arrays | covered | – | covered | covered | covered |
| Per-sample models and RHS | Single-thread | covered | – | covered | – | – |
| Half precision | Half precision | – | – | covered | covered | – |
| Dense linear algebra, large solvers | Tensors | – | – | covered | covered | covered |
| Ensembles and Monte Carlo | Regular ensembles, Uneven ensembles, Memory | covered | – | – | – | – |
| Divergent workloads | Uneven ensembles, Early-finish saving, Uneven-batch efficiency | – | – | – | – | – |
| Adaptive ODEs, embedded pairs | Adaptive ODEs | covered | – | – | – | – |
| Events and early exit | Uneven ensembles, Early-finish saving | – | – | – | – | – |
| Deployment outside Python | Deploy | covered | – | covered | covered | – |
| Differentiable simulation into learning | Derivatives, Single-thread, Uneven ensembles | covered | – | – | – | – |
| Ensemble data for training | Uneven ensembles, Regular ensembles, Your arrays | covered | – | – | – | – |
| Hybrid, physics-informed models | Derivatives, Single-thread, Your arrays, Deploy | covered | – | covered | – | – |
| Dense tensor training | Tensors, Array style, Half precision, Derivatives | – | – | covered | covered | – |
| Low-precision inference | Tensors, Half precision, Deploy | – | – | covered | covered | – |
| Array-style programs | Array style | – | – | covered | covered | covered |
| Feature | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Uneven ensembles | 162 ms (1.0× the best) ✓ | 335 ms (2.0× the best) | 1.03 s (6.3× the best) | 7.39 s (45× the best) | 3.69 s (22× the best) |
| Regular ensembles | 123 ms (1.0× the best) ✓ | 1.59 s (12× the best) | 1.03 s (8.3× the best) | 7.24 s (58× the best) | 3.60 s (29× the best) |
| Small jobs | 224 µs (1.0× the best) ✓ | 397 µs (1.7× the best) ✓ | 601 µs (2.6× the best) | 44.1 ms (190× the best) | 15.9 ms (70× the best) |
| Adaptive ODEs | 4.86 s (1.0× the best) ✓ | 33.2 s (6.8× the best) | 51.3 s (10× the best) | no reading | no reading |
| Early-finish saving | none (no saving) | 100% (1.0× the best) ✓ | none (no saving) | none (no saving) | none (no saving) |
| Uneven-batch efficiency | 7% (1.0× the best) ✓ | 3% (2.0× the best) | 1% (6.3× the best) | <1% (45× the best) | <1% (170× the best) |
| Memory | 61.8 MiB (1.0× the best) ✓ | 68.3 MiB (1.1× the best) ✓ | 182 MiB (2.9× the best) | 274 MiB (4.4× the best) | 169 MiB (2.7× the best) |
| Compile time | 631 ms (under 1 s: instant) | 478 ms (under 1 s: instant) | 74.3 ms (under 1 s: instant) ✓ | no reading | no compile step (nothing to compile) ✓ |
| Code size | 28 lines (1.1× the best) ✓ | 42 lines (1.7× the best) ✓ | 25 lines (1.0× the best) ✓ | 25 lines (1.0× the best) ✓ | 24 lines (1.0× the best) ✓ |
| Tensors | 2 of 5 Built for per-sample kernels and ensembles; for dense tensor work it hands arrays to PyTorch or JAX zero-copy. | 2 of 5 Compiles loops and NumPy-style code; dense linear algebra comes from the libraries it calls. | 5 of 5 ✓ Array programs written once and compiled by XLA; batched linear algebra, convolutions and broadcasting are first-class. | 5 of 5 ✓ Dense array maths is its home ground, with tuned libraries behind batched linear algebra, convolutions and broadcasting. | 4 of 5 ✓ The reference API for dense array maths and broadcasting on the CPU, with tuned BLAS and LAPACK underneath. |
| Array style | 2 of 5 A per-sample kernel language by design: you write one step of one sample, and whole-array code is left to array libraries, with which raptor exchanges arrays zero-copy. | 2 of 5 You mostly write loops over arrays; array expressions are secondary. | 4 of 5 ✓ NumPy-style array expressions, but functional and traced rather than eager. | 5 of 5 ✓ Eager tensor expressions are the programming model. | 5 of 5 ✓ The whole-array expression is the programming model, evaluated eagerly; the right choice for array code on the CPU. |
| Half precision | 1 of 5 Not supported. raptor is scoped to FP32 and FP64 numerics; half-precision and tensor-core work belongs with PyTorch or JAX. | 2 of 5 float16 arithmetic intrinsics in numba.cuda; no BF16/FP8 or tensor-core path. | 5 of 5 ✓ FP16, BF16 and FP8 types, with XLA targeting tensor cores. | 5 of 5 ✓ FP16, BF16 and FP8 types with tensor-core paths, including autocast. | 2 of 5 float16 storage and arithmetic, but slow on the CPU and nothing below it. |
| Single-thread | 5 of 5 ✓ You write one step of one sample; hawk and eagle handle threads, launches, stopping and compaction. | 3 of 5 A per-index body under prange or cuda.jit; indexing and launch are yours. | 4 of 5 ✓ A per-sample function under vmap; early stopping becomes masking you write. | 3 of 5 torch.func.vmap over a per-sample function; stopping and batching stay with you. | 1 of 5 Whole-array code; there is no per-sample model. |
| Derivatives | 5 of 5 ✓ Every kernel written in hawk's own vocabulary carries generated forward- and reverse-mode derivatives, on GPU and CPU. | 1 of 5 No automatic differentiation of its own. | 5 of 5 ✓ Forward and reverse mode through grad, jvp and vjp, on GPU and CPU. | 4 of 5 ✓ Autograd differentiates tensor programs; a custom kernel needs its backward written by hand. | 1 of 5 No automatic differentiation of its own. |
| Control | 2 of 5 By design hawk and eagle decide threads, launches and scheduling, so compaction can adapt to uneven batches; for hand-tuned thread-level kernels, Warp or Numba is the right choice. | 5 of 5 ✓ prange, explicit threads and typed loops; SIMD and memory layout are yours. | 2 of 5 Plain JAX leaves threads, vectorisation and layout to XLA; Pallas control is aimed at the GPU. | 2 of 5 Operators and a few custom-kernel hooks; launches are left to the framework. | 2 of 5 Strides and memory layout are yours to choose; threads and SIMD are left to the libraries underneath. |
| Your arrays | 4 of 5 ✓ Zero-copy through DLPack with a certified matrix (CuPy, PyTorch, Warp and NumPy today, not JAX). | 3 of 5 Reads NumPy arrays directly and exposes the CUDA array interface; wider exchange takes some glue. | 4 of 5 ✓ DLPack exchange with other frameworks, mostly without copies. | 4 of 5 ✓ DLPack and the array interface exchange tensors with other libraries, mostly without copies. | 4 of 5 ✓ The array protocols everyone reads, on the host; device memory is out of its scope. |
| Deploy | 4 of 5 ✓ A compiled kernel runs from any program that can load its manifest; today eagle is the loader. | 2 of 5 Ahead-of-time compilation exists in a limited form; most use stays inside Python. | 4 of 5 ✓ Compiled XLA programs can be exported and run from other runtimes. | 4 of 5 ✓ TorchScript, AOT export and a C++ runtime take models into non-Python programs. | 1 of 5 A Python library; nothing is compiled into a separate artefact. |
| Extensibility | 3 of 5 A plugin registry and a protocol spine; two backends today (CUDA and CPU threads), no second vendor yet. | 3 of 5 An extension API for new types and targets, at a low level. | 4 of 5 ✓ XLA and PJRT plugins add new hardware backends. | 4 of 5 ✓ Out-of-tree backends and custom operators are supported. | 3 of 5 Array-API dispatch lets other array libraries stand in. |
Two worlds, drawn as soft regions that blend where they meet; the blend is the boundary. A block of work is covered by a tool when the tool covers every feature the block needs: within 2× of the best tool on this device for a measured feature, 4 of 5 for a rubric one (italic: the author's judgement). Same rule for every tool; a dashed block is one no tool covers on this device. A tool's shape is the rounded convex hull of the blocks it covers and never encloses a block it does not cover (where one hull would, the tool is drawn in two or more pieces). Arrays cross zero-copy between raptor and CuPy, PyTorch, NVIDIA Warp and NumPy today, not JAX. The tools are complementary; overlap is not a ranking.
Radar for AMD EPYC 9B45, card of 2026-10-13, script cb2eb627. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.71 of the radius (mean of 4) | 0.52 of the radius (mean of 4) | 0.20 of the radius (mean of 3 of 4) | 0.29 of the radius (mean of 3 of 4) |
| Uneven ensembles | 142 ms (1.0× the best) | 328 ms (2.3× the best) | 1.86 s (13× the best) | 10.2 s (72× the best) | 7.72 s (54× the best) |
| Regular ensembles | 187 ms (1.0× the best) | 1.53 s (8.1× the best) | 1.94 s (10× the best) | 10.2 s (54× the best) | 7.65 s (40× the best) |
| Small jobs | 167 µs (1.0× the best) | 368 µs (2.1× the best) | 491 µs (2.9× the best) | 44.7 ms (260× the best) | 15.6 ms (92× the best) |
| Adaptive ODEs | 3.76 s (1.0× the best) | 19.9 s (5.3× the best) | 60.5 s (16× the best) | – | – |
| Footprint and turnaround | 0.90 of the radius (mean of 3) | 0.82 of the radius (mean of 3) | 0.81 of the radius (mean of 3) | 0.59 of the radius (mean of 2 of 3) | 0.82 of the radius (mean of 3) |
| Memory | 61.5 MiB (1.0× the best) | 68.4 MiB (1.1× the best) | 174 MiB (2.8× the best) | 275 MiB (4.4× the best) | 169 MiB (2.7× the best) |
| Compile time | 565 ms (under 1 s: instant) | 449 ms (under 1 s: instant) | 71.5 ms (under 1 s: instant) | – | no compile step (nothing to compile) |
| Code size | 28 lines (1.1× the best) | 42 lines (1.7× the best) | 25 lines (1.0× the best) | 25 lines (1.0× the best) | 24 lines (1.0× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.0 of 5 | 4.7 of 5 | 5.0 of 5 | 3.7 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 2 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 2.0 of 5 | 4.5 of 5 | 3.5 of 5 | 1.0 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 1 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 1 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 2.0 of 5 | 2.0 of 5 | 2.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 4 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 3 of 5 |
Radar for AMD EPYC 7B13, card of 2026-10-13, script cb2eb627. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.88 of the radius (mean of 4) | 0.57 of the radius (mean of 4) | 0.20 of the radius (mean of 3 of 4) | 0.37 of the radius (mean of 3 of 4) |
| Uneven ensembles | 400 ms (1.0× the best) | 398 ms (1.0× the best) | 2.15 s (5.3× the best) | 8.19 s (20× the best) | 4.07 s (10× the best) |
| Regular ensembles | 693 ms (1.0× the best) | 1.85 s (2.6× the best) | 2.14 s (3.0× the best) | 8.37 s (12× the best) | 4.04 s (5.8× the best) |
| Small jobs | 498 µs (1.1× the best) | 448 µs (1.0× the best) | 847 µs (1.8× the best) | 74.9 ms (160× the best) | 39.5 ms (88× the best) |
| Adaptive ODEs | 26.2 s (1.0× the best) | 31.9 s (1.2× the best) | 62.2 s (2.3× the best) | – | – |
| Footprint and turnaround | 0.88 of the radius (mean of 3) | 0.80 of the radius (mean of 3) | 0.79 of the radius (mean of 3) | 0.59 of the radius (mean of 2 of 3) | 0.82 of the radius (mean of 3) |
| Memory | 61.6 MiB (1.0× the best) | 68.2 MiB (1.1× the best) | 182 MiB (2.9× the best) | 275 MiB (4.4× the best) | 169 MiB (2.7× the best) |
| Compile time | 1.10 s (1-10 s: noticeable) | 712 ms (under 1 s: instant) | 123 ms (under 1 s: instant) | – | no compile step (nothing to compile) |
| Code size | 28 lines (1.1× the best) | 42 lines (1.7× the best) | 25 lines (1.0× the best) | 25 lines (1.0× the best) | 24 lines (1.0× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.0 of 5 | 4.7 of 5 | 5.0 of 5 | 3.7 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 2 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 2.0 of 5 | 4.5 of 5 | 3.5 of 5 | 1.0 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 1 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 1 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 2.0 of 5 | 2.0 of 5 | 2.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 4 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 3 of 5 |
Radar for Google Axion (Arm Neoverse-V2), card of 2026-10-13, script cb2eb627. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Ensemble speed | 0.95 of the radius (mean of 4) | 0.73 of the radius (mean of 4) | 0.75 of the radius (mean of 4) | 0.20 of the radius (mean of 3 of 4) | 0.34 of the radius (mean of 3 of 4) |
| Uneven ensembles | 301 ms (1.0× the best) | 388 ms (1.2× the best) | 410 ms (1.3× the best) | 3.02 s (10× the best) | 2.22 s (7.3× the best) |
| Regular ensembles | 648 ms (1.5× the best) | 1.80 s (4.3× the best) | 411 ms (1.0× the best) | 2.76 s (6.7× the best) | 2.20 s (5.3× the best) |
| Small jobs | 407 µs (1.0× the best) | 438 µs (1.0× the best) | 803 µs (1.9× the best) | 62.9 ms (150× the best) | 16.9 ms (41× the best) |
| Adaptive ODEs | 13.3 s (1.0× the best) | 22.5 s (1.6× the best) | 41.6 s (3.1× the best) | – | – |
| Footprint and turnaround | 0.93 of the radius (mean of 3) | 0.81 of the radius (mean of 3) | 0.76 of the radius (mean of 3) | 0.59 of the radius (mean of 2 of 3) | 0.79 of the radius (mean of 3) |
| Memory | 61.8 MiB (1.0× the best) | 67.6 MiB (1.0× the best) | 182 MiB (2.9× the best) | 217 MiB (3.5× the best) | 169 MiB (2.7× the best) |
| Compile time | 297 ms (under 1 s: instant) | 520 ms (under 1 s: instant) | 83.7 ms (under 1 s: instant) | – | no compile step (nothing to compile) |
| Code size | 28 lines (1.1× the best) | 42 lines (1.7× the best) | 25 lines (1.0× the best) | 25 lines (1.0× the best) | 24 lines (1.0× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.0 of 5 | 4.7 of 5 | 5.0 of 5 | 3.7 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 2 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 2.0 of 5 | 4.5 of 5 | 3.5 of 5 | 1.0 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 1 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 1 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 2.0 of 5 | 2.0 of 5 | 2.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 4 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 3 of 5 |
Radar for Intel Xeon Platinum 8581C, card of 2026-10-13, script cb2eb627. Each axis is defined in the list below the chart; hover or tap one for the numbers behind it.
| Axis | raptor | Numba | JAX | PyTorch | NumPy |
|---|---|---|---|---|---|
| Ensemble speed | 1.00 of the radius (mean of 4) | 0.65 of the radius (mean of 4) | 0.56 of the radius (mean of 4) | 0.20 of the radius (mean of 3 of 4) | 0.35 of the radius (mean of 3 of 4) |
| Uneven ensembles | 162 ms (1.0× the best) | 335 ms (2.0× the best) | 1.03 s (6.3× the best) | 7.39 s (45× the best) | 3.69 s (22× the best) |
| Regular ensembles | 123 ms (1.0× the best) | 1.59 s (12× the best) | 1.03 s (8.3× the best) | 7.24 s (58× the best) | 3.60 s (29× the best) |
| Small jobs | 224 µs (1.0× the best) | 397 µs (1.7× the best) | 601 µs (2.6× the best) | 44.1 ms (190× the best) | 15.9 ms (70× the best) |
| Adaptive ODEs | 4.86 s (1.0× the best) | 33.2 s (6.8× the best) | 51.3 s (10× the best) | – | – |
| Footprint and turnaround | 0.90 of the radius (mean of 3) | 0.81 of the radius (mean of 3) | 0.80 of the radius (mean of 3) | 0.59 of the radius (mean of 2 of 3) | 0.82 of the radius (mean of 3) |
| Memory | 61.8 MiB (1.0× the best) | 68.3 MiB (1.1× the best) | 182 MiB (2.9× the best) | 274 MiB (4.4× the best) | 169 MiB (2.7× the best) |
| Compile time | 631 ms (under 1 s: instant) | 478 ms (under 1 s: instant) | 74.3 ms (under 1 s: instant) | – | no compile step (nothing to compile) |
| Code size | 28 lines (1.1× the best) | 42 lines (1.7× the best) | 25 lines (1.0× the best) | 25 lines (1.0× the best) | 24 lines (1.0× the best) |
| Tensors and precision (qualitative) | 1.7 of 5 | 2.0 of 5 | 4.7 of 5 | 5.0 of 5 | 3.7 of 5 |
| Tensor workloads (qualitative) | 2 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 4 of 5 |
| Array-style programming (qualitative) | 2 of 5 | 2 of 5 | 4 of 5 | 5 of 5 | 5 of 5 |
| Half precision and below (qualitative) | 1 of 5 | 2 of 5 | 5 of 5 | 5 of 5 | 2 of 5 |
| One-sample authoring (qualitative) | 5.0 of 5 | 2.0 of 5 | 4.5 of 5 | 3.5 of 5 | 1.0 of 5 |
| Single-thread abstraction (qualitative) | 5 of 5 | 3 of 5 | 4 of 5 | 3 of 5 | 1 of 5 |
| Differentiable kernels (qualitative) | 5 of 5 | 1 of 5 | 5 of 5 | 4 of 5 | 1 of 5 |
| Low-level control (qualitative) | 2.0 of 5 | 5.0 of 5 | 2.0 of 5 | 2.0 of 5 | 2.0 of 5 |
| Reach (qualitative) | 3.7 of 5 | 2.7 of 5 | 4.0 of 5 | 4.0 of 5 | 2.7 of 5 |
| Works with your arrays (qualitative) | 4 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 4 of 5 |
| Deploy outside Python (qualitative) | 4 of 5 | 2 of 5 | 4 of 5 | 4 of 5 | 1 of 5 |
| Extensibility (qualitative) | 3 of 5 | 3 of 5 | 4 of 5 | 4 of 5 | 3 of 5 |
Every measured axis is the per-sample ensemble workload raptor is built for; dense tensor maths, training and half precision are the qualitative axes, where PyTorch and JAX lead. Outer is better; overlaps are complementary, not a ranking.
NVIDIA Warp gives you near-total control of every kernel, short of raw CUDA. raptor hands that control to the engine on purpose, so compaction and the launch shape are decided at run time; the two are different trade-offs, not a ranking.
Each of the six majors is the plain mean of its minor axes (the detailed radar draws every minor), with equal weights and the same rule for every tool; a minor a tool has no reading on is left out of its mean and the major's marker is drawn hollow. Hover or tap a major to see its minors.
Each measured axis is stretched over its own best-to-worst range, so ring labels differ per axis (compile time: fixed, 0.1 s to 100 s; code size: at least 4x). Axes are grouped by theme, so read the axes, not the area.
Italic axes are the author's judgement, not measurements: hollow markers, a linear scale, and no marker where a tool has no reading. A hollow marker on a measured axis means a minor is missing or, for compile time, is the tool's simple-kernel time. The hover panel has each axis's full wording.