LoginSign Up
← Back to all sparks
A

awkward

DEVOPS
Velocity5.0

Nested variable-length arrays for analysis

github.com/scikit-hep/awkward ↗

Awkward Array rewrote its kernels — 5x faster list reductions, and different layouts than before.

ragged arraysgpu kernelscudanumerical stabilityparticle physicsperformance
◆Current state
Awkward Array releases roughly monthly and has spent the past year rebuilding its compute layer. The CPU kernels were migrated from a parents-based to an offsets-based representation and the GPU kernels moved onto cuda.compute, culminating in 2.10.0's roughly 5x average speedup on list reductions. Since then the work has shifted to numerical robustness — overflow-safe, numerically stable implementations of var, std, mean, covar and corr — and to closing correctness gaps in the Numba lowering path.
◆Where it's heading
The project is converging on one kernel specification with CPU and GPU implementations kept in step, so new operations land on both backends in the same release rather than trailing months apart. The willingness to change internal layouts and accept different floating-point results in a minor release says the maintainers treat the kernel layer as private and are optimizing it accordingly. Recurring fixes for silent data corruption in the Numba and cppyy paths suggest the interop surfaces are where the remaining risk sits.
◆Prediction
Expect the parents-to-offsets migration to finish on the GPU side and the cuda.compute backend to keep absorbing operations that are still CPU-only, with the lazy IR scheduling layer added in 2.11.0 as the next thing to gain visible functionality.

◆Recent moves

  1. 14d ago

    2.12.0: overflow-safe statistics and CUDA argsort

    Rewrites var, std, moment, mean, covar and corr as fused two-pass sum-of-squares reducers so they stay overflow-safe and numerically stable — the natural follow-on to a release that rewrote the kernels for speed. argsort arrives on the CUDA backend, and native string lowering for Numba fixes a silent data corruption in that path.

    View source ↗
  2. 22d ago

    2.11.0: a lazy IR scheduling layer and saner parquet row-group defaults

    Adds a lazy IR scheduling layer — infrastructure rather than user-facing capability, but the kind that determines what optimizations are possible later. The parquet default row group size is corrected to match pyarrow's, which had been producing very large groups, and transient attrs no longer leak into written files.

    View source ↗
  3. 1mo ago

    2.10.0: kernels rewritten, list reductions about 5x faster

    ⚡ SPARK

    The payoff release for a year of kernel migration: list reductions run about 5x faster on average and over 10x on long lists, with both the CPU and GPU kernel sets rewritten. The notes are explicit that floating-point results may differ and internal layouts have changed — an unusually direct statement that the compute layer is private and was reshaped accordingly.

    View source ↗
  4. 2mo ago

    2.9.1: offsets-based reducers and big-endian support

    The staging release for the kernel rewrite — reducer kernels start taking offsets instead of parents, reducers are reimplemented on cccl, and parents allocation goes lazy, all described in the notes as precursors to removing parents entirely. Big-endian support is improved and tested, and byteorder is now carried through pickling.

    View source ↗
  5. 6mo ago

    Version 2.9.0

    A cleanup cut: Python 3.9 and PyPy support dropped, the old VirtualArray class deleted, and a handful of buffer and byteorder fixes. Nothing new for users, but it narrows the support matrix ahead of the kernel work.

    View source ↗
  6. 6mo ago

    2.8.12: sort, argmax and argmin arrive on the CUDA backend

    GPU coverage widens with ak.sort, and argmax and argmin implemented via CCCL, while ak.combinations gets faster on GPU by computing output list indexes with searchsorted. Named-axis handling also becomes thread-safe, with multi-threaded testing added to CI.

    View source ↗