Skip to content
CAI
Software that uses CAICheck a score

jax-ml/jax

58.3

Adequate · 14 November 2026

310.6k

lines of production code

Python

with C++

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Cloud TPU Colab notebooks and landing page

This change introduces a new \cloud\_tpu\_colabs\ directory containing a landing page (README) and several example Jupyter notebooks for running JAX on Cloud TPUs. The included notebooks demonstrate core JAX capabilities such as \pmap\ for parallel execution (Pmap\_Cookbook), automatic differentiation and basic NumPy operations (JAX\_demo, JAX\_NeurIPS\_2020\_demo), and physics simulations like the Lorentz ODE Solver and Wave Equation. The README provides guidance on running these examples in Colab or on Cloud TPU VMs, including performance notes on padding and bfloat16 precision.

_cloud\_tpu\colabs · high confidence

Add Grouped Matrix Multiplication (GMM) kernels for TPU

Introduces new grouped matrix multiplication operations for TPU via the \jax.experimental.pallas.ops.tpu.megablox\ module. The \gmm\ function performs grouped matrix multiplications using Pallas kernels, with a custom VJP implementation in \ops.py\ that supports efficient backpropagation for both the left-hand side and right-hand side matrices (including transposed variants). The implementation includes device-specific logic in \common.py\ to handle TPU generation differences, such as bfloat16 support on TPU v4 and later, and exposes the functionality through the \megablox\ package namespace.

jax/experimental/pallas/ops/tpu/megablox · high confidence

Add JAX implementation of scipy.cluster.vq.vq

Users can now use jax.scipy.cluster.vq.vq to assign observation vectors to the nearest code in a code book based on Euclidean distance. This new function returns both the assigned code indices and the corresponding distances, enabling vectorized clustering operations within JAX programs.

_jax/\src/scipy/cluster · high confidence

Add Mosaic GPU matrix multiplication benchmarks

Added a new benchmark suite for Mosaic GPU matrix multiplication operations, including both bf16\_i8 and f32 precision variants. The \matmul\_bench.py\ script and its associated \BUILD\ file allow users to measure performance metrics such as TFLOPS and speedup for specific matrix dimensions and tiling configurations on H100 GPUs.

benchmarks/mosaic · high confidence

Add Pallas TPU example kernels for all-gather and matmul

New example kernels for the Pallas TPU backend have been added to demonstrate custom collective operations and matrix multiplication. The \all\_gather\ kernel provides a pedagogical implementation of a ring-based all-gather collective using Pallas primitives, while the \matmul\ kernel shows how to write a tiled matrix multiplication kernel with configurable block shapes and accumulation types. These files serve as reference implementations for users building custom TPU operations with Pallas.

jax/experimental/pallas/ops/tpu · high confidence

Add example for serving jax2tf models with TensorFlow Model Server

New files have been added to the jax2tf serving example directory, including a README with step-by-step instructions, a Python script (model\_server\request.py) for sending inference requests via gRPC or HTTP REST, and an \\init\\_.py module. This enables users to export JAX models converted to TensorFlow SavedModels and serve them using the open-source TensorFlow Model Server, supporting both fixed and batch-polymorphic models.

jax/experimental/jax2tf/examples/serving · high confidence

Added Pallas-MGPU planar\_snake benchmark

A new benchmark for the Pallas-Mosaic-GPU \planar\_snake\ calculation has been added to the \benchmarks/pallas\ directory. This includes a Python script (\mgpu\_planar\_snake\_bench.py\) that measures latency across various grid shapes and tile widths, along with the corresponding BUILD configuration to run the test on GPU H100 full configurations.

benchmarks/pallas · high confidence

Added auto-generated documentation for JAX converter evaluation results and primitive coverage

The jax2tf documentation now includes auto-generated reports on model conversion success rates across various backends (jax2tf\_xla, jax2tf\_noxla, jax2tfjs, jax2tflite, jax2tflite+flex) and detailed tables of JAX primitive support by data type. These files, along with their templates, are built from test harnesses to keep the limitations and coverage information up to date.

jax/experimental/jax2tf/g3doc · high confidence

Added scipy.spatial.transform Rotation and Slerp classes

The \jax/\src/scipy/spatial/\\init\\_.py\ module has been initialized, establishing the package structure for the \scipy.spatial\ namespace within JAX. This change lays the groundwork for exposing SciPy spatial functionality, specifically supporting the \Rotation\ and \Slerp\ classes as indicated by the associated commit context.

_jax/\src/scipy/spatial, jax/scipy/spatial · medium confidence

Automatic distributed initialization for multiple cluster environments

JAX now automatically detects and initializes distributed runs in Slurm, Open MPI, MPI4py, Kubernetes, and Cloud TPU environments without requiring manual argument passing to \jax.distributed.initialize()\. A new \jax.\_src.clusters\ module provides a generic interface where specific cluster implementations (SlurmCluster, OmpiCluster, Mpi4pyCluster, K8sCluster, GkeTpuCluster, GceTpuCluster) are registered and checked in a defined order to auto-populate coordinator address, process count, and process ID. This allows users to launch distributed JAX jobs on these platforms with minimal configuration, as the system will handle the underlying discovery and connection setup automatically.

_jax/\src/clusters · high confidence

Experimental static key reuse checking

A new experimental module, jax.experimental.key\_reuse, has been added to detect the reuse of random keys within JAX programs. Users can enable this feature via the jax\_debug\_key\_reuse configuration flag or the jax.debug\_key\_reuse context manager; when active, attempting to use the same key twice will raise a KeyReuseError, helping prevent subtle bugs in random number generation.

_jax/experimental/key\reuse · high confidence

Expose JAX-compatible scipy.optimize interface

The jax/scipy/optimize module now explicitly exports the minimize function and OptimizeResults class, re-exporting them from the internal implementation source. This change makes the optimization capabilities available under the public jax.scipy.optimize namespace, allowing users to import and use these functions directly from the standard scipy.optimize path while leveraging JAX's transformations.

jax/scipy/optimize · high confidence

Expose Mosaic GPU MLIR dialect types and attributes via C API

The Mosaic GPU MLIR dialect is now accessible from external C/C++ code through a new C API. This exposes C-level functions to create, inspect, and manipulate key dialect components, including \TileTransformAttr\, \SwizzleTransformAttr\, various layout attributes (\WGSplatFragLayoutAttr\, \WGStridedFragLayoutAttr\, \TiledLayoutAttr\), and new data types such as \BarrierType\, \B6x16P32Type\, and \P2B6Type\. This enables other parts of the JAX ecosystem to interact directly with Mosaic GPU's internal representation.

jaxlib/mosaic/dialect/gpu/integrations · high confidence

Expose segment aggregation functions in jax.ops

Users can now import segment\_sum, segment\_prod, segment\_min, and segment\_max directly from jax.ops. These functions are re-exported from the internal jax.\_src.ops.scatter module to provide a public API for NumPy-style indexed segment aggregations.

jax/ops · high confidence

Expose sparse linear algebra solvers in jax.scipy.sparse.linalg

Users can now import and use the Conjugate Gradient (cg), Generalized Minimal Residual (gmres), and Biconjugate Gradient Stabilized (bicgstab) solvers directly from the public \jax.scipy.sparse.linalg\ module. This change establishes the public API surface for these sparse linear algebra operations, which are implemented in the internal source and re-exported for external consumption.

jax/scipy/sparse · high confidence

Initial OneAPI GPU backend support

This change introduces the foundational infrastructure for the Intel OneAPI (SYCL) GPU backend in JAX. It adds the build configuration (BUILD.bazel) and core runtime wrappers (oneapi\_gpu\_runtime) that map SYCL queue operations like memcpy, memset, and stream synchronization to JAX's internal status handling. The update also includes the plugin extension glue code (oneapi\_plugin\_extension) to register the backend with JAX's Python client, and implements the initial set of solver FFI kernels (oneapi\_solver\_kernels\_ffi) for linear algebra operations such as LU decomposition (getrf), enabling these computations to run on OneAPI-compatible hardware.

jaxlib/oneapi · high confidence

Initial support for Pallas Mosaic GPU lowering

JAX now includes an initial implementation of the Mosaic GPU backend for Pallas, enabling users to write and execute GPU kernels using the Mosaic programming model. This change introduces the \jax.\_src.pallas.mosaic\_gpu\ module, which provides the core lowering infrastructure, primitives, and pipelining logic required to translate Pallas kernels into Mosaic GPU operations. It also adds a \plgpu.as\_torch\_kernel\ helper to allow Mosaic GPU kernels to be called directly with PyTorch tensors, facilitating interoperability between JAX and the PyTorch ecosystem.

_jax/\_src/pallas/mosaic\gpu · high confidence

Introduce JAX Mosaic experimental module with TPU custom call bindings

A new \jax.experimental.mosaic\ package has been added to expose bindings for TPU custom calls and MLIR dialects. This module re-exports key components from \jax.\_src.tpu\_custom\_call\, including \Tiling\, \OptLevel\, \TpuMemorySpace\, and \register\_extra\_dialect\, while also providing access to the TPU dialect via \jax.\_src.lib.tpu\. This change makes these lower-level TPU-specific APIs available for experimental use in Mosaic.

jax/experimental/mosaic · high confidence

Introduce JAX OneAPI plugin for Intel GPU support

This change adds the initial infrastructure for a OneAPI PJRT plugin, enabling JAX to run on Intel GPUs. The \jax\_plugins/oneapi\ directory now contains the build rules (\BUILD.bazel\) to compile the \pjrt\_c\_api\_gpu\_plugin.so\ native library, along with Python packaging scripts (\plugin\setup.py\, \setup.py\) that define the \jax-oneapi-plugin\ and \jax-oneapi-pjrt\ packages. The plugin's \\\init\\_.py\ implements logic to dynamically load required OneAPI runtime libraries (such as SYCL, MKL, and Level Zero adapters) and registers the plugin via JAX's plugin entry points, allowing users to utilize Intel hardware acceleration.

_jax\plugins/oneapi · high confidence

Introduce JAX debugger with CLI, Colab, and web backends

JAX now includes a built-in debugger accessible via the \jax.debug.breakpoint()\ call, supporting three distinct backends: a command-line interface (CLI) for terminal-based debugging, a Colab-specific debugger for interactive notebook environments, and a web-based debugger that connects to a local web console. The CLI backend provides standard debugging commands like stepping through frames, printing variables, and viewing source context. The Colab backend renders code highlights and frame information directly in the notebook output. The web backend, powered by \web\_pdb\, binds to localhost by default and allows debugging via a web interface. Users can choose the backend via environment variables or configuration, with the CLI being the default when no specific backend is forced.

_jax/\src/debugger · high confidence

Introduce JAX2TF package with native serialization and call\_tf support

The jax/experimental/jax2tf package is now available, providing two-way interoperation between JAX and TensorFlow. Users can convert JAX functions to TensorFlow using jax2tf.convert (defaulting to native serialization via StableHLO and the XlaCallModule op) and call TensorFlow functions from JAX using jax2tf.call\_tf. The package includes support for shape polymorphism, SavedModel serialization, and custom gradients, with a new BUILD configuration and documentation to guide usage.

jax/experimental/jax2tf · high confidence

Introduce Mosaic GPU MLIR dialect for GPU kernel programming

Adds the \mosaic\_gpu\ MLIR dialect to JAX, providing a specialized set of operations and types for programming NVIDIA GPUs. This includes definitions for warp-group semantics, tensor memory (TMEM) management, asynchronous memory transfers (TMA), and collective matrix multiply (WGMMA) operations. The dialect enables lower-level control over GPU hardware features, supporting complex memory layouts and synchronization primitives required for high-performance custom kernels.

jaxlib/mosaic/dialect/gpu · high confidence

Introduce Mosaic GPU backend for JAX

Adds the Mosaic GPU backend to JAX, providing a new compilation and execution path for GPU kernels. This includes the core custom call implementation, MLIR pass pipelines for lowering GPU operations to PTX and SASS, serialization support for kernel caching, and debugging utilities for dumping intermediate compilation artifacts. The backend integrates with the XLA FFI and supports features like collective metadata and TMA descriptors.

jaxlib/mosaic/gpu · high confidence

Introduce Mosaic GPU experimental backend

Adds the \jax.experimental.mosaic.gpu\ package, providing a new GPU execution path for Pallas kernels. This includes a Python API for defining GPU kernels with \as\_gpu\_kernel\, utilities for managing barriers, semaphores, and shared memory, and support for warp-level matrix multiply-accumulate (WGMMA) and tensor core (TCGEN05) operations. The backend features a layout inference system to automatically determine memory layouts for fragmented arrays and handles lowering to the Mosaic GPU MLIR dialect, enabling high-performance custom kernels on NVIDIA GPUs.

jax/experimental/mosaic/gpu · high confidence

Introduce MosaicGPU wheel build infrastructure

Added the build files and packaging scripts necessary to create a standalone MosaicGPU Python wheel. This includes a Bazel build rule to compile the \mosaic\_gpu.so\ shared library, a linker script to expose specific symbols, and a \setup.py\ configuration that defines the package structure, CUDA-specific dependencies, and an entry point for the plugin.

jaxlib/mosaic/gpu/wheel · high confidence

Introduce Pallas TPU Interpret Mode with thread mapping and vector clocks

This change adds the \jax/\_src/pallas/mosaic/interpret\ package, providing the infrastructure for interpreting Pallas kernels on TPUs. It introduces a \thread\_map\ mechanism that executes kernel logic across multiple threads using a \ThreadPoolExecutor\, supporting both ordered and unordered IO callbacks. The package also includes a \vector\_clock\ implementation for tracking causal ordering of operations, \shared\_memory\ handling, and utility functions for padding and logging, all wired together via a new Bazel build target.

_jax/\src/pallas/mosaic/interpret · high confidence

Introduce Pallas as a new JAX subsystem for accelerator kernels

This change adds the \jax.\_src.pallas\ module, establishing the core infrastructure for Pallas—a new system for writing and executing custom kernels on accelerators. The diff introduces the \pallas\_call\ primitive for invoking these kernels, the \mpmd\_map\ primitive for multi-program multi-data execution, and a suite of primitives in \primitives.py\ (such as \load\, \store\, \program\_id\, and \num\_programs\) that form the Pallas language. It also includes a new HLO interpreter (\hlo\_interpreter.py\) for running kernels in interpret mode, helper utilities like \pl.kernel\ and \pl.loop\ in \helpers.py\, and the necessary Bazel build rules and test utilities to integrate Pallas into the JAX codebase.

_jax/\src/pallas · high confidence

Introduce Python bindings for the MLIR Triton dialect

This change adds the \jaxlib.triton\ module, providing Python bindings for the MLIR Triton dialect. It exposes core types like \PointerType\ and operations such as \ReduceOp\ and \ScanOp\ with improved return type inference, allowing users to interact with the Triton dialect directly within the JAX MLIR infrastructure.

jaxlib/triton · high confidence

Introduce Python bindings for the Mosaic TPU and GPU MLIR dialects

This change adds the initial Python bindings for the Mosaic TPU and GPU MLIR dialects, exposing them via \jax.experimental.mosaic\. The \BUILD\ file defines the build targets for \tpu\_dialect\ and \gpu\_dialect\, which generate Python wrappers for operations and enums. The \tpu.py\ module provides Python interfaces for TPU-specific operations like \vector\_load\, \vector\_store\, and \reinterpret\_cast\, while \mosaic\_gpu.py\ exposes the GPU dialect operations, including a custom \WarpMapOp\. Supporting files like \layout\_defs.py\ define necessary types such as \Direction\ and \ImplicitDim\ used by these bindings.

jaxlib/mosaic/python · high confidence

Introduce TPU Ragged Paged Attention kernel with auto-tuned block sizes

Adds a new \ragged\_paged\_attention\ kernel in \jax.experimental.pallas.ops.tpu\ designed for high-throughput inference on TPUs, supporting mixed prefill and decoding workloads. The implementation includes a reference implementation for validation, input validation logic, and a comprehensive auto-tuned block size table (\tuned\_block\_sizes.py\) optimized for TPU v6 configurations to maximize performance and avoid register spilling.

_jax/experimental/pallas/ops/tpu/ragged\_paged\attention · high confidence

Introduce dedicated ROCm build infrastructure and plugin extension

This change establishes the \jaxlib/rocm\ directory with a new \BUILD\ file defining HIP-based GPU kernels (such as RNN, solver, and linear algebra operations) and a \rocm\_plugin\_extension.cc\ that registers the ROCm-specific FFI handlers and device utilities. It also adds \rocm\_rpath.bzl\ to configure wheel-relative RUNPATHs for AMD ROCm libraries, ensuring the JAX wheel can locate dependencies at runtime, and \rocm\_version.bzl\ to expose the detected ROCm version to the build system.

jaxlib/rocm · high confidence

Introduce experimental Colocated Python API

Adds a new \jax.experimental.colocated\_python\ module providing an API to execute Python functions and classes on devices colocated with JAX accelerators. The module exposes \colocated\_cpu\_devices\ to map accelerator devices to their local CPU counterparts, a \colocated\_python\ decorator to wrap serializable Python functions for execution on those devices, and a \colocated\_python\_class\ decorator to wrap Python classes so their methods run on the backend. The implementation includes serialization logic to handle device and mesh roundtrips, an object registry for managing backend instance lifecycles, and thread-safe result storage.

_jax/experimental/colocated\python · high confidence

Introduce experimental JAX roofline API for performance modeling

Adds a new experimental \jax.experimental.roofline\ module that allows users to estimate the floating-point operations (FLOPs) and high-bandwidth memory (HBM) usage of JAX computations. The API provides a \roofline\ function and registration utilities to analyze primitives, including support for unary and binary operations (with broadcasting), cumulative reductions, and specific primitives like \gather\, \scatter\, and \conv\. This enables users to profile and understand the performance characteristics of their JAX models.

jax/experimental/roofline · high confidence

Introduce experimental Pallas Fuser API for manual kernel fusion

This change adds the \jax.\_src.pallas.fuser\ module, providing an experimental (private) API for manually fusing computations into Pallas kernels. It introduces the \fuser.fuse\ decorator to fuse surrounding computation into a single fusible operation, and the \fuser.fusible\ decorator to mark specific functions as fusion targets. The implementation includes support for static arguments, state discharge (converting Refs to pure values), and custom evaluation rules, all wired through a new Bazel build structure for the fuser components.

_jax/\src/pallas/fuser · high confidence

Introduce experimental array and pytree serialization library

This change introduces a new \jax.experimental.array\_serialization\ module that provides asynchronous checkpointing capabilities for JAX arrays and nested pytrees. It exposes a \GlobalAsyncCheckpointManager\ for managing concurrent serialization and deserialization operations, along with dedicated \save\ and \load\ functions for pytrees. The implementation leverages TensorStore with Zarr3 and zstd compression to handle storage, and includes utilities for serializing pytree structures and managing memory limits during I/O operations.

_jax/experimental/array\serialization · high confidence

Introduce experimental jax.experimental.thunky for XLA:GPU ThunkExecutor programming

Adds a new experimental module, jax.experimental.thunky, providing a Python interface to program the XLA:GPU ThunkExecutor directly. This includes utilities to convert compiled JAX executables into MLIR modules using the thunky dialect, splice thunk modules, and handle Jaxpr embedding and translation. The feature is now included in JAX wheels and built via the new BUILD configuration in jax/\_src/thunky.

_jax/\src/thunky · high confidence

Introduce experimental sparse matrix support in JAX

This change adds the \jax.experimental.sparse\ submodule, providing experimental support for sparse matrix operations. It introduces the \BCOO\ (batched coordinate) sparse array type, which is compatible with JAX transformations like JIT, vmap, and grad, and the \sparsify\ transform to seamlessly convert dense JAX functions to operate on sparse inputs. The module also includes sparse-aware versions of \grad\, \value\_and\_grad\, \jacfwd\, and \jacrev\, as well as utilities for creating sparse arrays (e.g., \sparse.eye\, \sparse.empty\, \sparse.random\_bcoo\) and low-level primitives for GPU-accelerated sparse linear algebra via cusparse/hipsparse.

jax/experimental/sparse · high confidence

Introduce jax.extend module for internal JAX machinery

The new \jax.extend\ module provides a structured set of submodules (backend, core, linear\_util, lowering, pallas, random, sharding, source\_info\_util, and xla) that expose JAX's internal implementation details to extension authors. This change consolidates scattered internal APIs into a single, documented entry point, allowing users to access lower-level components like PRNG implementations, sharding definitions, and XLA transformations, while explicitly noting that this module carries no compatibility guarantee across releases.

jax/extend · high confidence

Introduce jax.image public API with resize and scale\_and\_translate

Users can now import image manipulation functions directly from the \jax.image\ namespace. This new module exposes \resize\ (including the \ResizeMethod\ enum) and \scale\_and\_translate\, providing a public interface for image scaling and translation operations that are implemented using native JAX primitives to support vmap and gradients.

jax/image · high confidence

Introduce stateful Ref primitives and effects

Adds the internal \jax.\_src.state\ module, introducing \Ref\ types and associated primitives (\get\, \swap\, \addupdate\) that enable mutable state within JAX transformations. This change implements the underlying effect system (\ReadEffect\, \WriteEffect\, \AccumEffect\) and interpreter rules required to track and mutate these references, laying the groundwork for the public \jax.ref\ API.

_jax/\src/state · high confidence

Introduces the \`thunky\` MLIR dialect and GPU thunk execution infrastructure

Adds a new \jaxlib/thunky\ component that defines an MLIR dialect for representing XLA:GPU thunk sequences and buffer allocations. This includes the dialect definition (operations like \copy\, \memzero\, \while\, \cond\, and collective operations), C++ libraries for converting between MLIR modules and \GpuExecutableProto\, and a custom call handler (\thunky.inline\_module\) that lowers these MLIR representations into runtime thunks for execution on both CUDA and ROCm backends.

jaxlib/thunky · high confidence

Major restructuring of the lax module and introduction of new primitives

The \jax.\_src.lax\ package has been significantly reorganized: the monolithic \lax.py\ has been split into specialized submodules (e.g., \linalg\, \convolution\, \slicing\, \erf\, \fft\, \ann\, \scaled\dot\), and the \\\init\\_.py\ file now explicitly re-exports a comprehensive set of primitives and functions. This refactor introduces several new capabilities, including \lax.conv\_general\_dilated\_patches\ and \lax.conv\_general\_dilated\_local\ for extracting convolution patches and implementing locally connected layers, \lax.scaled\_dot\ for scaled dot products with optional scaling factors, and \lax.FftType\ for explicit FFT type specification. Additionally, the \erf\ module has been reimplemented with higher accuracy using polynomial approximations and custom JVP rules, and the \eval\_jaxpr\ primitive now has dedicated transformation rules for JVP, batching, linearization, and transposition.

_jax/\src/lax · high confidence

New Bazel repository rule for external test dependencies

A new Bazel repository rule, \external\_deps\_repository\, has been added to \third\_party/external\_deps\ to streamline the configuration of external test dependencies. This rule allows users to pass a list of dependency targets (e.g., ROCm PJRT imports) and automatically generates a \.bzl\ file containing an \EXTERNAL\_DEPS\ variable, which can then be loaded in other BUILD files to access those targets. This change supports the project's shift toward bzlmod by providing a structured way to manage external dependencies within the module system.

_third\_party/external\deps · high confidence

New CI infrastructure and documentation for JAX builds and tests

The \ci/\ directory now contains a comprehensive set of shell scripts and documentation that standardize how JAX artifacts are built and tested. New scripts handle building wheels for CUDA, ROCm, and OneAPI backends, while dedicated runners execute Bazel tests on CPU and GPU targets using both Remote Build Execution (RBE) and local strategies. The system is supported by new documentation (\CONTRIBUTING.md\, \README.md\) explaining the hybrid CI architecture, and utility scripts for parsing wheel metadata and configuring environment variables.

ci · high confidence

New CI utility scripts for build, testing, and environment management

This change introduces a new set of utility scripts in the \ci/utilities\ directory to support JAX's continuous integration workflows. Key additions include \setup\_build\_environment.sh\ for initializing the build environment and cloning XLA, \install\_wheels\_locally.sh\ for installing JAX wheels using \uv\, and \run\_docker\_container.sh\ for managing Docker containers with environment variable passing and Windows MSYS path conversion. Testing support is enhanced with \collect\_bazel\_test\_xmls.sh\ to normalize Bazel test results, \prepare\_rocm\_tests.sh\ and \rocm\_test\_env.sh\ for ROCm-specific test setup, and \setup\_portserver.sh\ to manage the portserver daemon. Additional utilities include \run\_auditwheel.sh\ for manylinux compliance checks, \set\_artifact\_tag\_flags.sh\ for wheel version stamping, \generate\_invocation\_id.py\ for Bazel invocation IDs, \report\_resultstore\_link.py\ for ResultStore reporting, and \convert\_msys\_paths\_to\_win\_paths.py\ for Windows path handling. A README.md documents these scripts.

ci/utilities · high confidence

New FFI example project with CPU, CUDA, and stateful demonstrations

A new \examples/ffi\ directory provides a complete, buildable example project for JAX's Foreign Function Interface. It includes C++ and CUDA implementations (built via CMake and nanobind) alongside Python wrappers that demonstrate key FFI capabilities: basic array operations (\rms\_norm\), global state caching (\counter\), input-output aliasing, attribute passing, and custom VJP autodiff. A CUDA-specific example shows end-to-end forward/backward kernel execution, while a GPU state example illustrates custom type registration and stateful handlers.

examples/ffi · high confidence

New JAX implementations for scipy.interpolate, scipy.linalg, and scipy.special

This change adds JAX-compatible implementations for several SciPy modules located in \jax/\_src/third\_party/scipy\. It introduces \RegularGridInterpolator\ for interpolating points on a regular rectangular grid (supporting linear and nearest methods), \funm\ for evaluating matrix-valued functions via Schur decomposition, and \betaln\ for computing the log of the beta function with improved accuracy for large inputs. Additionally, it provides a real-valued implementation of the Fresnel integrals (\fresnel\) in \scipy.special\, helper utilities for spectral analysis in \signal\_helper\, and the necessary license and initialization files to support these new third-party components.

_jax/\_src/third\party/scipy · high confidence

New JAX tools for sampler bias evaluation and IR conversion

This change introduces new utility scripts in the jax/tools directory. The evaluate\_sampler\_bias.py tool allows users to evaluate the accuracy of JAX random samplers by comparing empirical quantiles against analytical expectations from scipy, supporting various distributions. Additionally, jax\_to\_ir.py provides a way to convert JAX functions into serialized IR formats (HLO or TensorFlow graphs) for use in ahead-of-time compilation or external systems. A new pgo\_nsys\_converter.py script is also added to convert NVIDIA Nsight Systems profiles into the .pbtxt format for XLA's Profile Guided Latency Estimator.

jax/tools · high confidence

New MLIR Python bindings and Mosaic GPU dialect support

This change introduces a new build target and set of Python extension modules in \jaxlib/mlir/\_mlir\_libs\ that expose MLIR dialects and the new Mosaic GPU compiler infrastructure to Python. It adds nanobind-based bindings for the core MLIR library, GPU/NVGPU/LLVM/SparseTensor dialects, and specific JAX extensions for TPU (\\_tpu\_ext\), Triton (\\_triton\_ext\), and Mosaic GPU (\\_mosaic\_gpu\_ext\). These modules provide Python APIs for registering dialects, handling MLIR types and attributes (such as Mosaic's \BarrierType\, \TileTransformAttr\, and \SwizzleTransformAttr\), and managing traceback-to-location mapping for better error reporting. The build system also includes automated generation of \.pyi\ type stubs for these extensions to improve type checking for users.

_jaxlib/mlir/\_mlir\libs · high confidence

New Mosaic GPU examples for Blackwell matmul and flash attention

Added new example implementations for the Mosaic GPU experimental module, including a pipelined matmul kernel, a Blackwell-specific matmul kernel with support for collective MMA and 2-CTA execution, and a flash attention example. These examples are exposed as Python modules and include a Bazel build configuration with a multiplatform test harness to validate the matmul kernel on H100 GPUs.

jax/experimental/mosaic/gpu/examples · high confidence

New PRNG implementations (Philox and Threefry variants) and internal random module restructuring

JAX now supports additional Pseudorandom Number Generator (PRNG) algorithms, specifically Philox 2x32, Philox 4x32, and Threefry 4x32, in addition to the existing Threefry 2x32 and RngBitGenerator (RBG) implementations. Users can select these algorithms by passing the \impl\ argument (e.g., \impl='philox4x32'\) to \jax.random.key()\. This change also involves refactoring the internal random number generation code into a new \jax.\_src.random\ submodule, which organizes the PRNG implementations and core random distribution functions into separate files for better maintainability. Also in this area: 12 commits (0 fixes) modifying jax.

_jax/\src/random · medium confidence · unverified

New Pallas Mosaic TPU backend implementation

This change introduces the \jax.\_src.pallas.mosaic\ module, providing the core infrastructure for running Pallas kernels on TPU hardware. It includes the build configuration (\BUILD\), error handling utilities that parse MLIR locations into Python tracebacks, and a comprehensive set of primitives and lowering rules for the TPU's Vector Core (TC) and Sparse Core (SC). Key features exposed to users include support for memory spaces (HBM, VMEM, SMEM, Host), semaphore-based synchronization, PRNG operations, and specialized helpers for bit-packing and pipeline prefetching.

_jax/\src/pallas/mosaic · high confidence

New Pallas-based PRNG implementations for TPU

Added new Pallas kernel implementations for the Philox and Threefry pseudo-random number generators in \jax.experimental.pallas.ops.tpu.random\. These modules provide hardware-accelerated random bit generation on TPUs, exposing the \pallas\_threefry2x32\ PRNG implementation via the standard JAX PRNG interface. The change includes the kernel logic, utility functions for block-based indexing, and registration of the new Threefry implementation, enabling users to leverage Pallas for high-performance random number generation on TPU hardware.

jax/experimental/pallas/ops/tpu/random · high confidence

New ROCm build and wheel-fixing tooling

Added a suite of Python and shell scripts in build/rocm/tools to streamline ROCm wheel production and validation. build\_wheels.py orchestrates jaxlib and jax wheel builds (supporting both GCC and Clang compilers) via build.py, while fixwheel.py repairs wheels to be manylinux-compatible using auditwheel. Supporting utilities include get\_rocm.py for installing ROCm on Ubuntu and RHEL-based systems, blacken.sh for code formatting, libc.py and symbols.py for detecting glibc versions and symbols, and auditwheel integration to ensure binary compatibility.

build/rocm/tools · high confidence

New TPU-specific linear algebra implementations for SVD and polar decomposition

This change introduces a new \jax.\_src.tpu.linalg\ module containing JIT-compatible implementations of Singular Value Decomposition (SVD) and QDWH-based polar decomposition specifically optimized for TPUs. The SVD implementation uses the QDWH algorithm to compute singular values and vectors, supporting features like Hermitian matrices and computing subsets of singular values via \subset\_by\_index\. The polar decomposition implementation provides a numerically stable Halley iteration using QR or Cholesky decompositions. These additions provide TPU users with specialized, high-performance linear algebra routines that were previously not available in this location.

_jax/\src/tpu · high confidence

New and updated example scripts for variational inference, differential privacy, and SPMD training

The examples directory now includes new scripts for Automatic Differentiation Variational Inference (advi.py), Differentially Private SGD (differentially\_private\_sgd.py), and SPMD MNIST classification (spmd\_mnist\_classifier\_fromscratch.py), alongside an ONNX-to-XLA compiler demo (onnx2xla.py). Existing examples have been updated to use the new \jax.example\_libraries\ namespace (replacing \jax.experimental\ and \jax.api\), migrated to \jax.numpy\ (jnp), and modernized to use \jax.random.key\ and \random.fold\in\ for PRNG management. The MNIST VAE example now uses the \optimizers\ library instead of \minmax\, and the MNIST classifier example has increased its default batch size to 128 and removed the \absl\ dependency in favor of standard \if \\name\\_ == '\_\main\\_'\ execution.

examples · high confidence

New cuDNN integration module for fused attention and scaled matmul

JAX introduces a new \jax.\_src.cudnn\ package that provides low-level lowering infrastructure for cuDNN operations. This includes a \cudnn\_fusion\ decorator to lower computations to XLA cuDNN fusions, a \fused\_attention\_stablehlo\ module implementing the scaled dot-product attention (SDPA) API with support for multiple input layouts (BTNH, BNTH) and mask types, and a \scaled\_matmul\_stablehlo\ module enabling block-scaled matrix multiplication with specific lowerings for CUDA, ROCm, and CPU platforms.

_jax/\src/cudnn · high confidence

New jax.example\_libraries package for Stax and optimizers

JAX now includes a new \jax.example\_libraries\ package containing \stax\ (a functional neural network building library) and \optimizers\ (a minimal library for stochastic first-order optimizers). These modules are now officially part of the JAX distribution, providing example implementations and tools for building neural networks and training loops, with \stax\ supporting layer composition via \serial\ and \parallel\ and \optimizers\ providing initialization and update functions for parameters.

_jax/example\libraries · high confidence

New jax.extend.core API for primitives and trace introspection

JAX now exposes a new \jax.extend.core\ module that provides public access to core primitives (such as \jit\_p\, \call\_p\, and various \lax\ primitives like \polynomial\_p\ and \log2\_p\) and trace introspection utilities (including \TraceTag\, \set\_current\_trace\, and \take\_current\_trace\). This change consolidates initial and final style custom VJP primitives and re-exports RNG primitives, enabling advanced extension and debugging capabilities that were previously internal.

jax/extend/core · high confidence

New jax.extend.mlir module for public MLIR access

A new \jax.extend.mlir\ package has been introduced to provide a stable, public-facing interface for JAX's MLIR capabilities. This module re-exports core MLIR components—such as the IR and pass manager—from \jaxlib\—alongside key JAX-specific functions like \lower\_with\_sharding\_in\_types\, \serialize\_portable\_artifact\, and \hlo\_to\_stablehlo\. This change establishes a dedicated extension point for users to interact with MLIR internals without relying on internal implementation details.

jax/extend/mlir · high confidence

New jax.extend.mlir.dialects package exposes MLIR dialects

The \jax.extend.mlir.dialects\ module has been added, providing a public-facing Python package that re-exports MLIR dialect bindings (arith, builtin, chlo, func, math, memref, mpmd, scf, sdy, sparse\_tensor, stablehlo, and vector) from \jaxlib.mlir.dialects\. This change establishes a new import path for these dialects, replacing the previous reliance on internal implementation paths.

jax/extend/mlir/dialects · high confidence

New jax.scipy.stats module with distribution exports

The jax/scipy/stats directory now contains a public API that exposes a wide range of statistical distributions (including bernoulli, beta, binom, cauchy, chi2, dirichlet, expon, gamma, gennorm, geom, gumbel\_l, gumbel\_r, laplace, logistic, multinomial, multivariate\_normal, nbinom, norm, pareto, poisson, t, truncnorm, uniform, vonmises, and wrapcauchy) as well as utility functions like gaussian\_kde, mode, rankdata, and sem. Each distribution module re-exports specific methods (such as pdf, cdf, ppf, logpdf, etc.) from the internal implementation, making them directly accessible via jax.scipy.stats.

jax/scipy/stats · high confidence

New jax2tf examples for SavedModel, Keras reuse, and TensorFlow.js

The \jax/experimental/jax2tf/examples\ directory now includes a comprehensive set of examples demonstrating how to save JAX models as TensorFlow SavedModels, reuse them in larger Keras pipelines, and convert them to TensorFlow.js. The new \saved\_model\_lib.py\ provides a \convert\_and\_save\_model\ helper that allows users to save model parameters as separate variables (enabling fine-tuning and avoiding GraphDef size limits) and supports shape polymorphism. The \keras\_reuse\_main.py\ example shows how to load a jax2tf SavedModel as a \hub.KerasLayer\ and train a classifier on top of it in TensorFlow. Additionally, a Quickdraw CNN example demonstrates conversion to TensorFlow.js, and the MNIST examples (\mnist\_lib.py\, \saved\_model\_main.py\) have been updated to use \optax\ instead of \flax.optim\ and support both pure JAX and Flax model implementations.

jax/experimental/jax2tf/examples · high confidence

New multi-pass source mapper for Jaxprs and HLO

The \jax.experimental.source\_mapper\ module introduces a new framework for generating source maps across multiple compiler passes. It provides a registry of passes (e.g., \jaxpr\, \hlo:stable-hlo\, \hlo:original\) that can be executed to produce source maps for JAX intermediate representations. The module includes specific generators for Jaxprs and HLO dialects, handling both old and new HLO metadata formats, and exposes utilities to compile functions with specific environment flags and generate dump outputs containing the source map and generated code.

_jax/experimental/source\mapper · high confidence

New statistical distributions and functions in jax.scipy.stats

This change adds JAX implementations for several new probability distributions and extends existing ones with additional methods. New distributions include Bernoulli, Beta-binomial, Generalized Normal (gennorm), Geometric, Gumbel (left-skewed), and Dirichlet. Existing distributions such as Beta, Cauchy, Chi-squared, Exponential, Gamma, Binomial, and Poisson have been updated with new functions like CDF, survival function (SF), log-CDF, and percent point function (PPF) to better match SciPy's API. These additions allow users to perform more comprehensive statistical modeling and inference directly within JAX.

_jax/\src/scipy/stats · high confidence

New suite of microbenchmarks for JAX core operations

Added a comprehensive set of new benchmark scripts to the \benchmarks/\ directory to measure the performance of various JAX capabilities. These include \api\_benchmark.py\ for JIT and eager dispatch, \math\_benchmark.py\ for unary and binary math operations, \linalg\_benchmark.py\ for linear algebra functions (SVD, QR, LU, etc.), \random\_benchmark.py\ for PRNG key handling, \sparse\_benchmark.py\ for BCOO/BCSR sparse operations, \shape\_poly\_benchmark.py\ for symbolic shape manipulation, \cache\_benchmark.py\ for internal caching, and \tracing\_benchmark.py\ for tracing and lowering overheads. All benchmarks utilize the \google\_benchmark\ library and include proper device-skip logic and \block\_until\_ready\ calls.

benchmarks · high confidence

New type stubs for LAPACK eigenvalue, Schur, and SVD modules

Added Python type stubs (\.pyi\) for the \jaxlib.cpu.\_lapack\ package, defining the \eig\, \schur\, and \svd\ submodules. These stubs introduce \ComputationMode\ and \Sort\ enums that specify options for computing eigenvectors, Schur vectors, and singular value matrices (full, min, or none), providing static type information for these linear algebra operations.

_jaxlib/cpu/\lapack · high confidence

Open-source PagedAttention TPU kernel with quantization and soft capping support

The PagedAttention TPU kernel is now available as an open-source component in JAX, providing a high-performance attention implementation optimized for TPU hardware. This release introduces support for quantized K/V pages (int8), allowing users to leverage reduced memory footprint and potentially faster inference with quantized models. Additionally, the kernel now supports attention logits soft capping, enabling better control over attention distribution for specific model architectures. The implementation includes a reference grouped query attention (GQA) implementation for validation and testing purposes.

_jax/experimental/pallas/ops/tpu/paged\attention · high confidence

Splash attention module now exposes public API via \_\_init\_\_.py

The \jax.experimental.pallas.ops.tpu.splash\attention\ package now includes an \\\init\\_.py\ file that explicitly exports key classes and functions, including \BlockSizes\, \QKVLayout\, \SegmentIds\, various mask types (\CausalMask\, \FullMask\, \LocalMask\, \Mask\, \MultiHeadMask\, \NumpyMask\), and factory functions (\make\_masked\_mha\_reference\, \make\_masked\_mqa\_reference\, \make\_splash\_mha\, \make\_splash\_mha\_single\_device\, \make\_splash\_mqa\, \make\_splash\_mqa\_single\_device\, \make\_causal\_mask\, \make\_local\_attention\_mask\, \make\_random\_mask\). This allows users to import these symbols directly from the \splash\_attention\ package namespace rather than navigating deeper into submodules.

_jax/experimental/pallas/ops/tpu/splash\attention · high confidence

jax.scipy restructuring and API expansion

The jax.scipy package has been restructured to expose a significantly expanded set of submodules and functions, including new modules for cluster (vq), fft (dct, idct), integrate (trapezoid), and interpolate (RegularGridInterpolator), alongside a comprehensive linalg module with support for decompositions (LU, QR, Cholesky, SVD, Schur, expm), special matrices, and solvers. The public API now imports these from internal sources, while deprecated or removed legacy modules like misc and stats have been deleted, and specific functions such as lpmn and lpmn\_values are now explicitly deprecated with warnings.

jax/scipy · high confidence

Removals

Deprecate jax.lib.xla\_bridge and migrate to internal source

The public module jax.lib.xla\_bridge has been removed, and its functionality has been moved to the internal package jax.\_src.lib. Users relying on jax.lib.xla\_bridge will encounter import errors; they should migrate to the new internal paths or use the stable public APIs provided by jax directly. The jax.lib package now re-exports the version string from the internal source.

jax/lib · high confidence

Architecture

Consolidate experimental build targets into jax/experimental/BUILD

The build configuration for experimental modules has been consolidated into a single \jax/experimental/BUILD\ file. This change introduces visibility controls via package groups (e.g., \buffer\_callback\_users\, \mosaic\_users\) and re-exports internal implementation targets (such as \//jax/\_src:buffer\_callback\) to the public experimental namespace, streamlining the build structure for experimental APIs.

jax/experimental · high confidence

JAX neural network module relocated to jax.\_src.nn

The implementation of the JAX neural network module (jax.nn), including activation functions, initializers, and attention utilities, has been moved from the public jax/nn directory into the internal source package jax/\_src.nn. This change establishes the new internal layout for these components, which are still accessible via the public jax.nn API.

_jax/\src/nn · high confidence

Move JAX ops implementation to jax.\_src.ops

The implementation of JAX's indexed update and segment operations (including scatter, gather, and segment reductions) has been moved from the public jax.ops module into the internal jax.\_src.ops package. This change consolidates the source code for these operations into a dedicated submodule, separating the internal implementation details from the public API surface while maintaining the existing functionality for users.

_jax/\src/ops · high confidence

Refactor control flow primitives into a dedicated module

The control flow primitives (scan, while\_loop, cond, switch, fori\_loop, map, and cumulative reductions) have been reorganized from a single monolithic file into a structured package under jax/\_src/lax/control\_flow. This change introduces separate modules for loops, conditionals, and solvers, along with shared utilities for type-checking and constant merging, improving code maintainability and internal organization without altering the public API.

_jax/\_src/lax/control\flow · high confidence

Restructure internal test utilities into a dedicated package

The internal test utilities previously located in the top-level test directory have been moved into a new \jax/\_src/internal\_test\_util\ package. This change introduces a dedicated \lax\_test\_util.py\ module for lax-specific test helpers and a \deprecation\_module.py\ to manage deprecation warnings, while ensuring these internal modules avoid top-level imports to improve modularity and maintainability.

_jax/\_src/internal\_test\util · high confidence

Restructure jaxlib GPU build and kernel registration

The jaxlib/gpu directory has been reorganized to consolidate shared CUDA and ROCm GPU kernels into a new build target. This change introduces a dedicated BUILD file that defines the \gpu\_plugin\_extension\ library and exports a comprehensive set of kernel source files (including linear algebra, sparse, RNN, and Triton kernels). It also adds new helper infrastructure such as \handle\_pool\ for managing GPU library contexts, \ffi\_wrapper\ for legacy kernel compatibility, and \gpu\_kernel\_helpers\ for unified error handling across CUDA and ROCm backends. Additionally, GPU-specific FFI handlers are now explicitly registered in \gpu\_kernels.cc\, centralizing the dispatch logic for operations like LU decomposition, SVD, and sparse matrix-vector products.

jaxlib/gpu · high confidence

jax.numpy namespace restructured into modular subpackages

The \jax.numpy\ package has been refactored from a single monolithic \lax\_numpy.py\ module into a structured namespace with dedicated submodules. Implementation logic is now split into \jax.\_src.numpy.lax\_numpy\ (core operations), \jax.\_src.numpy.array\_constructors\ (e.g., \array\, \asarray\), \jax.\_src.numpy.array\_creation\ (e.g., \zeros\, \linspace\), \jax.\_src.numpy.einsum\, and \jax.\src.numpy.indexing\. Additionally, \jax.numpy.fft\ and \jax.numpy.linalg\ are now explicit subpackages that re-export their respective functions. A new \jax/numpy/\\init\\_.pyi\ type stub file has been added to provide static type checking for the public API.

jax/numpy · high confidence

jaxlib build system restructured with new Bazel rules and module organization

The jaxlib build configuration has been significantly reorganized. The BUILD file now loads a comprehensive set of custom macros from jaxlib:jax.bzl (such as nanobind\_extension, pytype\_strict\_library) and jaxlib:pywrap.bzl, replacing previous inline or external definitions. The package visibility is locked down to //jax:internal by default, and the main jaxlib pytype\_strict\_library now explicitly depends on a wide array of internal MLIR dialects (e.g., stablehlo\_dialect, chlo\_dialect, sdy\_dialect) and C++ extensions (e.g., \_jax, \_ifrt\_proxy, \_pathways, \_pretty\_printer). This reflects a shift towards a more modular, strictly typed, and internally encapsulated build structure for the jaxlib Python extension.

jaxlib · high confidence

Behavioural changes

143 commits (10 fixes) modifying jax/experimental/pallas/ops/gpu

A change to existing behaviour in jax/experimental/pallas/ops/gpu — 143 commits (10 fixs), 11 files: “\[Pallas:MGPU\] Improve the benchmark harness for Blackwell matmul”; “\[Pallas:MGPU\] Avoid bubbles between steps of the MN loop in the Hopper matmul”; “\[Pallas:MGPU\] Allocate a unique buffer per device in LHS all gather matmul”; and 140 more.

jax/experimental/pallas/ops/gpu · medium confidence · unverified

27 commits (2 fixes) modifying jax/\_src/pallas/mosaic\_gpu/interpret

A change to existing behaviour in jax/\_src/pallas/mosaic\_gpu/interpret — 27 commits (2 fixs), 2 files: “\[bazel\] enable pyrefly type checking in \jax/\_src/pallas\”; “\[Pallas\]\[GPU kernel interpreter\] Support cluster barriers”; “Fix numpy dependency”; and 24 more.

_jax/\_src/pallas/mosaic\gpu/interpret · medium confidence · unverified

4 commits (0 fixes) modifying jax/pallas

A change to existing behaviour in jax/pallas — 4 commits, 6 files: “\[pallas\] Deprecated \pl.GridSpec\”; “Expose the Pallas, TPU, TPU SparseCore, Mosaic GPU, and fuser APIs under \jax.pallas\ (\jax.pallas\, \jax.pallas.tpu\, \jax.pallas.tpu\_sc\, \jax.pallas.mosaic\_gpu\, and \jax.pallas.fuser\)”; “\[pallas\] Deprecated \pallas\_call\_p\”; and 1 more.

jax/pallas · medium confidence · unverified

CPU linear algebra and sparse kernels moved to XLA FFI with nanobind bindings

The CPU backend in jaxlib/cpu has been restructured to implement LAPACK, BLAS, tridiagonal solve, and CSR sparse kernels via the XLA Foreign Function Interface (FFI) instead of legacy custom calls. This change introduces new C++ kernel implementations (e.g., lapack\_kernels.cc, sparse\_kernels.cc) and Python extension modules (\_lapack, \_sparse) built with nanobind, enabling better integration with SciPy's LAPACK/BLAS libraries and supporting features like pivoted QR factorization and parallel batch processing for linear algebra operations on CPU devices.

jaxlib/cpu · high confidence

Deprecate jax.experimental.compilation\_cache in favor of jax.\_src.compilation\_cache

The public experimental compilation cache module (jax.experimental.compilation\_cache) now acts as a thin wrapper that re-exports only set\_cache\_dir and reset\_cache from the internal implementation (jax.\_src.compilation\_cache). This change signals that the experimental module is being deprecated and that users should migrate to the internal source for full functionality, while the experimental entry point remains available for backward compatibility with these two specific functions.

_jax/experimental/compilation\cache · high confidence

Deprecate jax.experimental.pjit APIs and prune exports

The \jax.experimental.pjit.NamedSharding\ and \jax.experimental.pjit.PartitionSpec\ classes are now deprecated in favor of their counterparts in \jax.sharding\. Additionally, several internal or experimental symbols previously exported from \jax.experimental.pjit\ have been removed from the public API surface. Also in this area: Improved error handling for ordered effects and expanded custom\_jvp3 support; Improvements to custom JVP/VJP handling and Mosaic GPU lowering; Expanded Mosaic GPU primitives and pipeline buffering controls; Dead-code elimination now respects live Ref inputs and pointwise ops can distribute over pending reductions; Resharding now applies to non-floating point types during dtype promotion; and 36 more.

_jax/\src, python · high confidence

Deprecation of the Pallas Triton GPU backend

The Pallas Triton backend for GPU execution is now deprecated and will be removed in a future JAX version. Users relying on \pl.pallas\_call\ with the Triton backend will receive a deprecation warning and are advised to migrate to the Mosaic GPU backend for Pallas or use the official Triton bindings with \jax\_triton\. This change is implemented in the new \jax/\src/pallas/triton\ module, which now explicitly warns on use and registers the lowering rule for the \\\_gpu$xla.gpu.triton\ custom call target.

_jax/\src/pallas/triton · high confidence

Document and centralize JAXCI environment variables

The CI environment configuration is now centralized in \ci/envs/default.env\ and \ci/envs/docker.env\, with a new \ci/envs/README.md\ documenting all \JAXCI\\\ variables. This change introduces explicit support for OneAPI builds (defaulting to version 2025.1), allows configuring the Bazel output base to prevent disk space issues, and provides granular control over test execution via variables like \JAXCI\_IGNORE\_TESTS\ and \JAXCI\_EXTRA\_TEST\_ENV\. Docker-specific settings are also standardized, pointing to the new \ml-build\ container images.

ci/envs · high confidence

Establishes public API and type stubs for jax.nn

The \jax.nn\ module now exposes a comprehensive public interface for neural network operations, including activation functions (such as \silu\, \mish\, \squareplus\, and \log1mexp\), normalization utilities like \standardize\, and attention helpers like \dot\_product\attention\. This change introduces explicit type stubs (\\\init\\_.pyi\) to provide static type checking support and reorganizes the module structure by moving the core implementation into \jax.\_src.nn\ while maintaining backward-compatible exports. Users can now rely on consistent, typed access to these common NN functions directly from the \jax.nn\ namespace.

jax/nn · high confidence

Finalize deprecation of zero-dimensional inputs to jnp.nonzero

The \jnp.nonzero\ function now raises an error when passed zero-dimensional (scalar) inputs, finalizing the deprecation of this usage. This change aligns the function's behavior with NumPy's handling of scalar inputs and ensures consistent error reporting for invalid argument shapes.

_jax/\src/numpy · high confidence

Internal restructuring of JAX sparse linear algebra solvers

The implementation of JAX's sparse linear algebra solvers (including CG and BiCGSTAB) has been moved from the public API into the internal module \jax.\_src.scipy.sparse.linalg\. This change consolidates the solver logic, including helper functions for matrix-vector products and tolerance handling, into a private source location, separating the internal implementation details from the public interface.

_jax/\src/scipy/sparse · high confidence

JAX 0.11.2 release

This update releases JAX version 0.11.2 and synchronizes the jaxlib version to 0.1.77. The release includes a comprehensive set of changes such as the deprecation of several APIs (including \jax.experimental.pjit.NamedSharding\, \jax.interpreters.pxla\ symbols, and various \jax.core\ functions), the removal of deprecated modules like \jax.abstract\_arrays\ and \jax.experimental.maps\, and the introduction of new features like \jax.scipy.stats.gaussian\_kde\ and \jax.lax.split\. It also addresses build and dependency updates, including upgrades to XLA, Bazel, and various Python tooling, alongside numerous bug fixes and performance improvements.

(repo-wide) · high confidence

JAX version bump to 0.10.0

The JAX library has been updated to version 0.10.0. This release includes the finalization of deprecations for several \jax.core\ APIs, the removal of deprecated symbols from \jax.dlpack\, \jax.errors\, \jax.lib.xla\_bridge\, \jax.lib.xla\_client\, and \jax.lib.xla\_extension\, and the removal of the \jax.\_src\ module from the public JAX namespace.

jax · high confidence

Lazy loading of MLIR dialects and introduction of StableHLO alias

The \jax.\_src.lib.mlir.dialects\ module now uses lazy loading for most MLIR dialects (such as \arith\, \builtin\, \cf\, \gpu\, \mhlo\, etc.), importing them from \jaxlib.mlir.dialects\ only when accessed, which improves startup performance. Additionally, the \stablehlo\ dialect is explicitly imported and aliased as \hlo\ to abstract the transition from MHLO to StableHLO, while \mpmd\ and \sdy\ dialects are loaded eagerly.

_jax/\src/lib/mlir/dialects · high confidence

Migration of JAX SciPy implementation to private source namespace

The JAX SciPy module has been moved from the public \jax.scipy\ namespace into the private internal package \jax.\_src.scipy\. This change consolidates the implementation files (such as \fft.py\, \linalg.py\, \signal.py\, \special.py\, and \ndimage.py\) under the private source tree, marking the end of the public \jax.scipy\ API and preparing for its removal in a future version. Users relying on the public \jax.scipy\ interface should be aware that this location is now considered internal implementation detail.

_jax/\src/scipy · high confidence

New API for defining custom PRNG implementations

The \jax.\_src.extend\ module now provides \jax.extend.random.define\_prng\_impl\, a function that allows users to register custom pseudo-random number generator (PRNG) implementations by specifying key shape, seed, split, random\_bits, and fold\_in behaviors. This replaces the previous \extend.random.PRNGImpl\ class-based approach, offering a more streamlined interface for extending JAX's random number generation capabilities.

_jax/\src/extend · high confidence

New Bazel-based build system and CLI for JAX

The build process has been restructured to use a new Bazel-based system with a dedicated CLI (\build/build.py\) and \build/BUILD.bazel\ targets. This change introduces hermetic Python support, allowing builds to specify a Python version explicitly, and centralizes dependency management through \requirements.in\ and \test-requirements.txt\ processed by \rules\_python\. The new system also adds support for building various wheel artifacts (including CUDA, ROCm, and OneAPI plugins) and editable installs, while providing utilities like \parallel\_accelerator\_execute.sh\ for test distribution and \update\_requirements\_uv.py\ for lockfile generation.

build · high confidence

New Bazel-based wheel build infrastructure for jaxlib and GPU plugins

The jaxlib build system now uses a new set of Bazel rules and Python scripts (build\_wheel.py, build\_gpu\_kernels\_wheel.py, build\_gpu\_plugin\_wheel.py, build\_mosaic\_wheel.py) to assemble and package jaxlib, CUDA/ROCm/OneAPI plugin wheels, and Mosaic GPU wheels. This change introduces dedicated targets (jaxlib\_wheel, jaxlib\_wheel\_editable, jax-cuda-plugin, jax-rocm-pjrt, mosaic-gpu-plugin) that manage source collection, platform-specific setup.cfg generation, and editable installs, while also adding a wheel size verification test (wheel\_size\_test.py) and a ROCm dependency collector (rocm\_wheel\_deps.bzl). The LICENSE.txt file has been moved to jaxlib/tools, and the DUCC FFT license block was removed from it.

jaxlib/tools · high confidence

New CUDA plugin extension and version introspection module

The \jaxlib/cuda\ directory now contains the core CUDA plugin extension (\cuda\_plugin\_extension\) and a new version introspection module (\\_versions\). The plugin extension exposes FFI types and handlers (including GPU callback and DCE sink handlers) and provides a \get\_device\_ordinal\ utility, while the version module exposes runtime and build-time version checks for CUDA libraries (cuBLAS, cuDNN, etc.) and device capabilities (compute capability, multicast support). This change also introduces a compile-time requirement for CUDA 11.8 or newer and switches the Python binding implementation from pybind11 to nanobind.

jaxlib/cuda · high confidence

New JAX export serialization format and shape polymorphism decision logic

The export module now uses a new FlatBuffers-based serialization schema (serialization.fbs) to store JAX exports, introducing versioned support for explicit sharding, named shardings, memory spaces, and various float8/dtype types (e.g., f8\_e4m3, f8\_e3m4, e8m0fnu). This new format replaces the previous HloSharding-based serialization and includes a serialization version field to manage schema evolution. Additionally, the module introduces a new decision procedure (shape\_poly\_decision.py) for handling inequalities and bounds of symbolic dimensions in shape polymorphism, improving the reasoning for constraints involving equality and greater-than-or-equal relationships.

_jax/\src/export · high confidence

New modular ROCm plugin package structure

The ROCm GPU plugin is now distributed as a dedicated, version-specific package (e.g., \jax\_rocm7\_plugin\) located in \jax\_plugins/rocm\. This change introduces a new build and initialization flow where the plugin detects the installed ROCm major version to load the correct extension, registers custom FFI types and call handlers for the 'ROCM' platform, and includes a warning for multi-GPU setups if shared memory is insufficient. Users benefit from clearer version isolation and explicit support for Python 3.12–3.14 in the plugin metadata.

_jax\plugins/rocm · high confidence

Pallas API reorganization and deprecation cleanup

The \jax.experimental.pallas\ module has been reorganized to expose a unified public API while consolidating backend-specific functionality into dedicated submodules (\pallas.mosaic\_gpu\, \pallas.tpu\, \pallas.triton\, \pallas.tpu\_sc\, and \pallas.fuser\). This change introduces deprecation warnings for several legacy symbols, including \pl.core\_map\ (use \pl.kernel\), \pl.dot\ (removed in favor of \jax.numpy.dot\ or \einsum\), and \pl.reciprocal\ (moved to \pltpu\). The \pallas\_call\ primitive is now the standard entry point for kernel execution, and backend-specific compiler parameters and memory spaces are now accessed via their respective submodules.

jax/experimental/pallas · high confidence

Pallas ops module now registers its directory as user code for source info

The \jax/experimental/pallas/ops/\_\init\\_.py\ module now explicitly registers its own directory as a user-code location for JAX's source information tracking. This ensures that stack frames originating from Pallas operations are not filtered out during debugging or error reporting, allowing users to see full tracebacks and source context for Pallas-specific code.

jax/experimental/pallas/ops · high confidence

Public API reorganization and expansion in jax.lax

The \jax.lax\ module has been restructured to expose a curated public API while moving internal implementation details to private source paths. This change introduces numerous new primitives and functions—including \broadcast\_like\, \polynomial\, \integer\_pow\, \exp2\, \log2\, \mulhi\, \one\_minus\_square\, \reduce\_precision\, \ragged\_dot\, and \optimization\_barrier\—along with a new \jax.lax.linalg\ submodule for linear algebra operations (e.g., \cholesky\, \eigh\, \svd\, \tridiagonal\solve\). Simultaneously, many previously public internal helpers (prefixed with \\\, such as \\_delta\, \\_complex\, \\_reduce\_sum\) and deprecated symbols (e.g., \zeros\_like\_array\, \prod\, \infeed\, \outfeed\) have been removed from the public namespace to reduce clutter and enforce cleaner usage patterns.

jax/lax · high confidence

Python 3.15 support and improved Bazel build reliability

The build system now supports Python 3.15, including the free-threaded variant, by adding checksums for the CPython 3.15.0rc1 standalone builds and updating the \rules\_python\ configuration. To ensure reliable package resolution, patches were applied to \rules\_python\ to fix pure-Python wheel matching on Bazel modules (bzlmod) by including the 'none' ABI tag, and to support local wheel overrides for development workflows. Additionally, Windows build stability is improved by patching the Python site initialization to correctly handle long file paths via extended-length prefixes, and by bumping \rules\_python\ to version 2.2.0.

_third\party/py · high confidence

ROCm build infrastructure modernized with manylinux wheels, new Docker images, and CI automation

The ROCm build and CI system has been overhauled to support modern packaging and testing workflows. The build process now generates manylinux-compliant wheels for JAX and JAXlib, replacing the previous direct installation methods. New Dockerfiles (Dockerfile.ms, Dockerfile.jax-ubu22, Dockerfile.jax-ubu24) provide hermetic build environments for Ubuntu 22.04 and 24.04, with updated ROCm versions (6.0.0/6.2.0) and Python 3.11/3.12 support. A new CI build script (ci\_build) and associated test target files (ci\_blocking\_test\_targets.txt, ci\_test\_targets.txt) automate wheel building and test execution, including dynamic spawn strategies for remote build execution (RBE). The legacy build\_rocm.sh script is deprecated in favor of the new wheel-based approach, and the old Dockerfile.rocm has been removed.

build/rocm · high confidence

ROCm wheel builds migrate to manylinux and integrate Clang

The ROCm wheel build process now uses a manylinux\_2\_28 base image and installs LLVM 18 with Clang support, replacing previous build environments. This change includes a new configuration file (clang.cfg) that directs Clang to use the system GCC toolchain for standard libraries, ensuring compatibility during compilation. Additionally, the build environment now explicitly installs numactl-devel to resolve library linking issues and supports a broader range of GPU architectures, including new gfx12xx targets.

_build/rocm/build\wheels · high confidence

Refactored build CLI with subcommands and hermetic Bazel 9.2.0 support

The build tooling has been restructured to use a subcommand-based CLI architecture, moving utility functions into dedicated modules (command.py, utils.py) and introducing a CommandBuilder/SubprocessExecutor for managing subprocess execution with optional detailed timestamped logging. This change also upgrades the default Bazel version to 9.2.0, including hermetic toolchain support for Linux aarch64 builds, and updates the build scripts to reflect these structural and dependency changes.

build/tools · high confidence

Refactored image resizing implementation into a dedicated source module

The internal implementation of image resizing functions has been moved from the public \jax.image\ namespace into a new private module at \jax.\_src.image\. This change includes the introduction of new interpolation methods, specifically AREA resizing and PYTORCH\_CUBIC, and adds documentation clarifying the output data type of \jax.image.resize\. The refactoring also ensures consistent handling of negative dimensions in scaling operations and prevents NaN values in the Lanczos kernel and scaling logic.

_jax/\src/image · high confidence

Relocate third-party code to internal source directory

The third-party code previously located in jax.third\_party has been moved to jax.\_src.third\_party. This change reorganizes the internal structure of the library, placing third-party components within the private source tree alongside other internal implementation details.

_jax/\_src/third\party · high confidence

Reorganization of JAX interpreters into private source modules

The JAX interpreter modules, including automatic differentiation (ad), rematerialization (remat), and partial evaluation (partial\_eval), have been moved from the public \jax.interpreters\ namespace to the private \jax.\_src.interpreters\ package. This change consolidates these internal components under a single \jax/\_src/interpreters\ directory structure, ensuring they are no longer part of the public API surface while maintaining their functionality for internal JAX operations.

_jax/\src/interpreters · high confidence

Restructure CUDA plugin into a dedicated package with explicit library loading

The CUDA plugin code has been moved from jaxlib into a new jax\_plugins/cuda package, introducing a standalone build (BUILD.bazel) and Python packaging (setup.py, pyproject.toml) for the plugin. This change restructures how the plugin is distributed and loaded: the plugin now explicitly loads NVIDIA libraries (cuBLAS, cuDNN, etc.) up front via ctypes to ensure they are found, and the Python entry point is registered via jax\_plugins entry points rather than relying on the previous jaxlib internal extension structure.

_jax\plugins/cuda · high confidence

Restructured internal library module with new Mosaic GPU and Triton bindings

The \jax.\_src.lib\ package has been reorganized into a dedicated source location (\jax/\_src/lib\) with a new Bazel build file, consolidating imports from \jaxlib\ and exposing updated bindings. This change introduces Python bindings for the Mosaic GPU MLIR dialect (via \mosaic\_gpu.py\) and the Triton MLIR dialect (via \triton.py\), while also updating the internal profiler interface (\\_profiler.pyi\) and refining CUDA path detection logic.

_jax/\src/lib · high confidence

Switch linting to Ruff and expose MLIR passmanager

The MLIR module initialization now uses Ruff instead of flake8 for linting configuration and explicitly imports the \jaxlib.mlir.passmanager\ module, making the pass manager available to users of the JAX MLIR bindings.

_jax/\src/lib/mlir · high confidence

Update JAX C++ example to use OpenXLA CPU API and modern PJRT interfaces

The JAX C++ example has been migrated from the legacy TensorFlow XLA paths to the public OpenXLA CPU API. This update switches the build system to use standard C++ rules and links against the new \xla\_cpu\_pjrt\_client\ instead of the old CPU device target. In the code, the example now uses \GetXlaPjrtCpuClient\ for client initialization, \CompileAndLoad\ for compilation, and \BufferFromHostLiteral\ with explicit memory spaces. It also updates the logging library from TensorFlow's to Abseil, changes the HLO script reference from \jax\_to\_hlo.py\ to \jax\_to\_ir.py\, and uses the asynchronous \ToLiteral().Await()\ method for retrieving results.

_examples/jax\cpp · high confidence

Updated gRPC integration with Bazel plugin flag support

The gRPC third-party dependency has been updated to version 1.81.0. This change introduces support for passing custom flags to the gRPC code-generation plugin via a new \plugin\_flags\ argument in the \cc\_grpc\_library\ rule. Additionally, the build configuration has been cleaned up by removing temporary include paths for \upb-gen\ and \upbdefs-gen\ that were previously marked as workarounds for code-generation issues.

_third\party/grpc · high confidence

Fixes

Fix crash returning a Token from a jit computation on GPU

Resolves a crash that occurred when a JIT-compiled function returned a Token on GPU devices. This change ensures that Token values are handled correctly during JIT execution on GPU, preventing runtime errors in computations that rely on ordered effects or token passing.

jax/interpreters · high confidence

Fixes for JAX Bzlmod builds

This change resolves build issues with JAX when using Bazel's Bzlmod system. It introduces a new BUILD.bazel file for the third-party protobuf dependency, applies a patch to work around compiler and static analysis complaints regarding incomplete types in message\_lite.h, and adds a public alias for the arena target to ensure proper visibility.

_third\party/protobuf · high confidence

Test coverage

88 commits adding/updating tests in tests/numerics; Added Colab test notebooks for CPU, GPU, and TPU; Added Flax model examples for jax2tf testing; Added Pallas export backward compatibility test data; Added TSAN test configuration and wrapper for RBE environments; Added backward compatibility test data for tf.call\_tf\_function; Added multiprocess test for JAX2TF multihost export; Added tests for FFI example modules; Added tests for JAX scipy line\_search compatibility; Added tests for JAX thunky GPU programming primitives; Expanded test coverage for JAX core and experimental features; Expanded test coverage for jax2tf conversion and shape polymorphism; Extensive Pallas test suite expansion and maintenance; Initial test suite for Mosaic GPU dialect and layout inference; New FileCheck tests for JAX MLIR lowering; New export backward-compatibility test data for device placement and LAPACK solvers; Open-source multiprocess test suite and runner; Removal of legacy JAX test suite files.

Dependencies

Regenerated Python 3.12, 3.13, and 3.14 dependency lock files

The hermetic Python dependency lock files for Python 3.12, 3.13, and 3.14 (including the free-threaded 3.14 variant) have been regenerated using \uv\. This update refreshes the pinned versions and cryptographic hashes for all transitive dependencies, ensuring that builds for these Python versions use the latest compatible package sets defined in the source requirements.

(dependencies) · high confidence

Upgraded Abseil to LTS 20260526.0 with build fixes

The Abseil library has been upgraded to the LTS 20260526.0 release, which includes patches to improve Bazel build compatibility and fix compiler header usage. Specifically, the btree iterator type definition has been simplified to remove conditional logic, and the raw\_hash\_set implementation now includes immintrin.h for x86/x86\_64 platforms instead of bmi2intrin.h to resolve build issues.

_third\party/absl · high confidence

Housekeeping

Regenerated Python type stubs for jaxlib.\_jax

The Python type stubs (.pyi files) in the jaxlib.\_jax package have been regenerated to align with the current C++ bindings. This update refreshes the type signatures for core components including the JaxRuntimeError exception, CompileOptions, the pytree registry and definitions, and the guard libraries, ensuring that static type checkers and IDEs receive accurate information about the available APIs and their expected argument and return types.

_jaxlib/\jax · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 57 → 58 (+1.6)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 71 → 71 (-0.8)
  • Architecture 93 → 94 (+0.4)
  • Maturity 70 → 83 (+12.8)
  • Readiness 70 → 70 (+0.0)
  • Security 66 → 57 (-8.4)
  • Accessibility 42 → 49 (+6.9)
  • Performance 89 → 89 (+0.0)

Resolved (154)

  • Change coupling: compute_on.py ↔ fused.py (jax/_src/compute_on.py)
  • Change coupling: compute_on.py ↔ xla_metadata.py (jax/_src/compute_on.py)
  • Change coupling: pjit.py ↔ fused.py (jax/_src/pjit.py)
  • Classify ADR enforcement: Custom JVP/VJP rules for JAX-transformable functions (docs/jep/2026-custom-derivatives.md)
  • Classify ADR enforcement: Design of Type Promotion Semantics for JAX (docs/jep/9407-type-promotion.md)
  • Classify ADR enforcement: JEP 9263: Typed keys & pluggable RNGs (docs/jep/9263-typed-keys.md)
  • Classify ADR enforcement: Jax and Jaxlib versioning (docs/jep/9419-jax-versioning.md)
  • Classify ADR enforcement: Omnistaging (docs/jep/4410-omnistaging.md)
  • Classify ADR enforcement: custom_vjp and nondiff_argnums update guide (docs/jep/4008-custom-vjp-update.md)
  • Duplicated block (10 lines × 2) (docs/_static/fault_tolerance/data_parallelism.py)
  • Duplicated block (10 lines × 2) (jax/_src/pallas/mosaic_gpu/primitives.py)
  • Duplicated block (10 lines × 2) (jax/experimental/mosaic/gpu/fragmented_array.py)
  • Duplicated block (10 lines × 2) (jax/experimental/pallas/ops/gpu/layer_norm.py)
  • Duplicated block (10 lines × 3) (jax/_src/random/philox2x32.py)
  • Duplicated block (10–11 lines × 2) (jax/_src/lax/slicing.py)
  • Duplicated block (10–14 lines × 2) (jax/_src/lax/lax.py)
  • Duplicated block (10–17 lines × 2) (jax/_src/pallas/mosaic_gpu/primitives.py)
  • Duplicated block (11 lines × 2) (jax/_src/pallas/mosaic_gpu/primitives.py)
  • Duplicated block (11 lines × 2) (jax/experimental/pallas/ops/gpu/all_gather_mgpu.py)
  • Duplicated block (11 lines × 2) (jax/experimental/pallas/ops/gpu/layer_norm.py)
  • …and 134 more

New (497)

  • Change coupling: sc_core.py ↔ tpu_sc.py (jax/_src/pallas/mosaic/sc_core.py)
  • DotAlgorithmPreset._convert_to_hlo_attr (cyclomatic 19) (jax/_src/lax/lax.py)
  • Duplicated block (10 lines × 2) (jax/_src/lax/exp_log.py)
  • Duplicated block (10–11 lines × 2) (jax/_src/lax/parallel.py)
  • Duplicated block (10–11 lines × 2) (jax/_src/lax/slicing.py)
  • Duplicated block (10–13 lines × 2) (jax/_src/scipy/bessel.py)
  • Duplicated block (11–12 lines × 2) (jax/_src/lax/lgamma.py)
  • Duplicated block (11–12 lines × 3) (jax/experimental/mosaic/gpu/fragmented_array.py)
  • Duplicated block (12 lines × 2) (docs/_static/fault_tolerance/data_parallelism.py)
  • Duplicated block (12 lines × 2) (jax/_src/scipy/linalg.py)
  • Duplicated block (12 lines × 2) (jaxlib/tools/build_gpu_kernels_wheel.py)
  • Duplicated block (12–15 lines × 2) (jax/experimental/mosaic/gpu/tcgen05.py)
  • Duplicated block (12–17 lines × 2) (jax/_src/scipy/bessel.py)
  • Duplicated block (13 lines × 2) (jax/_src/lax/lax.py)
  • Duplicated block (13 lines × 2) (jax/_src/scipy/bessel.py)
  • Duplicated block (14 lines × 2) (docs/_static/fault_tolerance/data_parallelism.py)
  • Duplicated block (14–17 lines × 2) (jax/experimental/pallas/ops/gpu/all_gather_mgpu.py)
  • Duplicated block (15 lines × 3) (jax/_src/tpu_info.py)
  • Duplicated block (15 lines × 3) (jax/_src/tpu_info.py)
  • Duplicated block (46–50 lines × 2) (jax/_src/pallas/mosaic_gpu/primitives.py)
  • …and 477 more

Changes since last survey

  • 300 commits — 265 feature/other, 35 fixes

By area

  • jax/_src — 131 commits
  • (repo) — 22 commits
  • (root) — 22 commits
  • jax/experimental — 21 commits
  • .github/workflows — 13 commits
  • tests/BUILD — 12 commits
  • jaxlib/mosaic — 10 commits
  • tests/numerics — 10 commits
  • tests/pallas — 8 commits
  • docs/pallas — 5 commits
  • jax/numpy — 4 commits
  • tests/partitioning_test.py — 3 commits
  • jaxlib/pjit.cc — 2 commits
  • jaxlib/xla_client.py — 2 commits
  • tests/lax_autodiff_test.py — 2 commits
  • tests/lax_scipy_special_functions_test.py — 2 commits
  • tests/linalg_test.py — 2 commits
  • tests/random_lax_test.py — 2 commits
  • .github/actions — 1 commit
  • benchmarks/shape_poly_benchmark.py — 1 commit

Notable commits

  • fix: Add JAX regression tests for CPU YNNPACK broadcast dot-reduce bugs.
  • fix: Add mode="high" to jax.random.truncated_normal to fix tail sampling accuracy.
  • fix: Add regression test for TPU gather grad bug.
  • fix: Fix BCOO reshape with dense dimensions
  • fix: Fix CHECK failure in DeviceList.is_fully_addressable on an empty DeviceList.
  • fix: Fix jnp.nan_to_num double replacement of substituted values (jax-ml/jax#42406)
  • fix: Fix an edge-case crashes in _reshape_sharding_rule.
  • fix: Fix jnp.choose for narrow index dtypes and large choice counts
  • fix: Fix jnp.kron and jnp.vander for boolean inputs
  • fix: Fix memory leak and missing traversal validation when unpickling PyTreeDef.
  • fix: Fix mixed-size scipy.signal convolutions
  • fix: Fix non-termination in jnp.gcd and jnp.lcm for minimum signed integers.
  • fix: Fix sharding specs of untiled collectives in partial-manual shard_map with Explicit axes.
  • fix: Fix small-input scipy.special.i1e reference rounding in bessel_test and enable bfloat16 subnormals on GPU.
  • fix: Merge pull request #42041 from zhenying-liu:rejoin-step-fix
  • fix: Merge pull request #42063 from BlazeSR10hawk:fix/scipy-signal-mixed-size-42061
  • fix: Merge pull request #42190 from BlazeSR10hawk:fix/weighted-quantile-zero-weight-42189
  • fix: Merge pull request #42313 from bhaskargurram-ai:fix/jit-cache-key-static-args
  • fix: Merge pull request #42319 from bhaskargurram-ai:fix/interp-inf-fp
  • fix: Merge pull request #42430 from kratos0718:fix-choice-empty-shape
  • …and 280 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

jax-ml/jax was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 75ce26614ff821b14e4343e813e9a0108209484f — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.