Repository navigation
chore(deps): update dependency jax to v0.12.1 - #462
Open
renovate[bot] wants to merge 1 commit into
Open
renovate[bot] wants to merge 1 commit into
renovate[bot] wants to merge 1 commit into
Conversation
renovate
Bot
force-pushed
the
renovate/jax-0.x
branch
from
November 8, 2026 16:55
e7d1cfc to
681c737
Compare
Codecov Report✅ All modified and coverable lines are covered by tests. Additional details and impacted files@@ Coverage Diff @@
## main #462 +/- ##
=======================================
Coverage 74.68% 74.68%
=======================================
Files 2 2
Lines 79 79
=======================================
Hits 59 59
Misses 20 20 ☔ View full report in Codecov by Harness. 🚀 New features to boost your workflow:
|
renovate
Bot
force-pushed
the
renovate/jax-0.x
branch
8 times, most recently
from
November 13, 2026 20:29
55b441e to
7096d8d
Compare
renovate
Bot
force-pushed
the
renovate/jax-0.x
branch
5 times, most recently
from
November 18, 2026 05:06
c13cb8d to
5d0b025
Compare
renovate
Bot
force-pushed
the
renovate/jax-0.x
branch
from
November 18, 2026 19:47
5d0b025 to
e15e8f3
Compare
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Note
This PR body was truncated due to platform limits.
This PR contains the following updates:
0.4.30→0.12.1Release Notes
jax-ml/jax (jax)
v0.12.1Compare Source
New features
jax.pallas(jax.pallas,jax.pallas.tpu,jax.pallas.tpu_sc,jax.pallas.mosaic_gpu, andjax.pallas.fuser, via explicitimport jax.pallas). Existing imports fromjax.experimental.pallasremain valid, whiletritonandopsstay underjax.experimental.pallas. See {ref}pallas-changelogfor Pallas-specificchanges.
with_logsoption to {func}jax.gradand{func}
jax.value_and_grad, returning backward-pass logs alongsidegradients without calling {func}
jax.vjpdirectly. Withwith_logs=True,gradreturns(grad, logs)(or(grad, aux, logs)whenhas_aux=True),and
value_and_gradreturns(val, (grad, logs))(or((val, aux), (grad, logs))).jax.avals(along withMesh.axesandAbstractMesh.axes) forconcise construction of abstract array types (
ShapedArray) withoptional sharding annotations, such as
f32[3@X]andf32[()].jax.debug.printnow accepts PEP 750template strings (for example,
jax.debug.print(t"hello {x}"))({jax-issue}
#41565).F8E4M3FN_F8E4M3FN_F32_X3andF8E4M3FN_F8E4M3FN_F32_X4to{class}
jax.lax.DotAlgorithmPreset(andjax_default_matmul_precision)for emulating
bfloat16precision matrix multiplications onbfloat16orfloat32inputs using 3 or 4float8_e4m3fnproducts accumulated infloat32.jax.lax.DotAlgorithmPreset.F16_F16_F32, fixing{func}
jax.nn.dot_product_attentionwithimplementation="xla"andfloat16inputs underjitandgradon CPU.jax.lax.fmaand {func}jax.lax.fmuladdfor fusedmultiply-add (
a * b + c).fmaperforms a single-rounding fusedmultiply-add where supported;
fmuladduses fused multiply-add whenavailable and falls back safely otherwise ({jax-issue}
#23919).{func}
jax.lax.polynomialnow usesfmuladdfor floating-point evaluation.jax.lax.sinpi, {func}jax.lax.cospi, and{func}
jax.lax.tanpi, which computesin(pi * x),cos(pi * x), andtan(pi * x)more accurately than multiplying bypifirst. They returnexact values at integers and half-integers and stay accurate for large
inputs. Window functions ({func}
jax.numpy.blackman,{func}
jax.numpy.hamming, {func}jax.numpy.hanning),{func}
jax.scipy.signal.stft, {func}jax.scipy.special.fresnel, andLanczos {func}
jax.image.resizenow use them for better accuracy.jax.lax.asinpi, {func}jax.lax.acospi,{func}
jax.lax.atanpi, and {func}jax.lax.atan2pi, which compute theinverse trigonometric functions divided by
pi(asin(x) / pi,acos(x) / pi,atan(x) / pi, andatan2(x, y) / pi).jax.lax.exp2m1and {func}jax.lax.log2p1, which compute2**x - 1andlog2(1 + x)without losing precision nearx = 0.jax.scipy.special.gammaincinvand{func}
jax.scipy.special.gammainccinv, the inverses of the regularizedlower and upper incomplete gamma functions, with gradients with respect to
both arguments ({jax-issue}
#5350).jax.scipy.special.jn, {func}jax.scipy.special.yn,{func}
jax.scipy.special.iv, and {func}jax.scipy.special.kn, providingaccurate evaluation of integer-order Bessel functions and modified Bessel
functions of the first and second kind (for static integer orders, with
support for real and complex inputs and automatic differentiation).
jax.scipy.special.ndtri_exp, the inverse of{func}
jax.scipy.special.log_ndtr(ndtri(exp(y))without underflow orcancellation in log-probability space), supporting accurate forward-,
reverse-, and higher-order differentiation.
jax.numpy.histogram_bin_edgesand {func}jax.numpy.histogramnowaccept
bins="sqrt"andbins="sturges"to choose bin countsautomatically, matching NumPy ({jax-issue}
#42199).deviceargument to {func}jax.numpy.logspaceand{func}
jax.numpy.geomspace({jax-issue}#41659).correctionargument (NumPy 2.0 alias forddof)to {func}
jax.numpy.nanvarand {func}jax.numpy.nanstd({jax-issue}
#41696).modekeyword argument to {func}jax.random.normal(controlled by the new
jax_random_normal_modeconfig option, default"low")."low"keeps existing behavior (truncating around ±5.3 standarddeviations in
float32);"high"uses more random bits per sample (~±6.3in
float32, ±9.4 infloat64), and"highest"uses two random streamsto reach roughly ±9.1 in
float32without enablingx64.modeargument to{func}
jax.random.truncated_normal(default"low"). Settingmode="high"improves tail accuracy and eliminates boundary clamping spikes at extreme
truncation bounds and in 16-bit floating-point types.
num_streamsargument to {func}jax.random.bitstogenerate a tuple of
1,2, or4independent unsigned integer arrays inparallel from the underlying generator's native bit streams.
out_shardingsupport to {func}jax.lax.scatter(andscatter_add,scatter_sub,scatter_mul,scatter_min,scatter_max,scatter_apply), {func}jax.lax.gather, {func}jax.numpy.take(
Array.take), {func}jax.numpy.take_along_axis, {func}jax.numpy.sum,{func}
jax.numpy.max, {func}jax.numpy.quantile,{func}
jax.numpy.nanquantile, and {func}jax.numpy.nanpercentile(andnative pass-through in {func}
jax.numpy.percentile).jax.lax.top_k, {func}jax.lax.approx_max_k, and{func}
jax.lax.approx_min_know support sharded reduction axes underexplicit sharding.
jax.dlpack.from_dlpack(and {func}jax.numpy.from_dlpack) nowaccept
jax.experimental.layout.Formatin theirdeviceargument tospecify device-local layouts (such as a linear layout
tiling=((1,),)forTPU pinned host memory buffers,
kDLTPUHost;Layout.AUTOis notsupported). When
copy=None, importingkDLTPUHostbuffers now falls backto copying if zero-copy sharing is not possible.
jax.experimental.serialize_executable.serializenow supports savingand loading compiled functions that capture large constant arrays (see
Breaking changes regarding format version).
pipextras (jax[rocm],jax[rocm7],jax[rocm10], andper-GPU-target
jax[rocm7-device-<gfxNNN>]/jax[rocm10-device-<gfxNNN>]) to install AMD's TheRock ROCm wheels directlyfrom AMD's package index without a pre-installed system ROCm
(
jax[rocm7-local]remains for pre-installed ROCm) ({jax-issue}#41331).Breaking changes
jax_use_simplified_jaxpr_constantsconfiguration flag is nowTrueby default. Non-scalar constant arrays captured from outside a jitted
function are now passed as separate inputs to compiled executables rather
than embedded inline, reducing executable size and avoiding host copies
during lowering. See {ref}
constants-notefor details, including how torecognize a breakage and migrate your code. You can temporarily set
JAX_USE_SIMPLIFIED_JAXPR_CONSTANTS=Falseto restore the previous behavior;the flag will be removed in a future release.
(
jax_use_shardy_partitioner=False). JAX now always uses the Shardypartitioner, which has been the default for about a year. Custom
partitioning rules in
jax.experimental.custom_partitioningthat onlyimplement legacy GSPMD callbacks (instead of
sharding_rule) now raiseNotImplementedError.{func}
jax.experimental.serialize_executable.serializeto version 3 tosupport captured constant arrays. Loading executables saved with JAX
0.12.0or earlier via{func}
jax.experimental.serialize_executable.deserialize_and_loadnowraises
ValueError.jax.randomsamplers now propagateout_shardingdirectly per shardinstead of falling back to automatic sharding or inserting hidden
all-gathers. Requesting an
out_shardingthat shards non-key dimensionsnow requires a partitionable generator (
threefry2x32,rbg, orunsafe_rbg, withjax_threefry_partitionable=True), raisingNotImplementedErrorotherwise. Conflicting parameter shardings orsharding non-batch axes in composite samplers (
permutation,categorical,multivariate_normal,orthogonal,poisson) now raiseShardingTypeError.jax.random.poissonwithmethod="exact"(the default) now keepsthe first accepted sample per element so draws do not depend on how the
array is sharded across devices. This can change the exact integer values
drawn for multi-element arrays when
lam >= 10.jax.numpy.histogramnow requiresout_shardingto be fullyreplicated (raising
ShardingTypeErrorotherwise) and, under explicitsharding, requires
weightsto match the sharding ofa.jax.scipy.signal.welchand {func}jax.scipy.signal.csd(as well as{func}
jax.scipy.signal.stftwhen explicitly passednperseg=None) nowdefault
npersegto256whenwindowis a string or tuple, matchingSciPy and the documentation. Previously, inputs longer than
256used thefull signal length, so output shapes and values may change
({jax-issue}
#40012).Deprecations
jax.sharding.SingleDeviceShardingis deprecated. Usejax.sharding.make_single_device_shardingto construct a single-devicesharding, and
jax.sharding.is_single_device_shardingto check whether asharding targets a single device (replacing
isinstance(..., SingleDeviceSharding)).jax_use_shardy_partitionerconfiguration flag is deprecated and is nowa no-op (setting it to
Falseis silently ignored). JAX always uses theShardy partitioner, and the flag will be removed in a future release.
jax.scipy.special.bessel_jnis deprecated; use{func}
jax.scipy.special.jninstead, which is more accurate and evaluatesonly the single
n-th Bessel function directly (note thatbessel_jnreturned all orders
0..v, whereasjn(n, z)returns only ordern).Changes
XLA_CLIENT_MEM_FRACTIONnor its deprecated aliasXLA_PYTHON_CLIENT_MEM_FRACTIONis set, JAX now preallocates 75% of GPUmemory at startup and allows the default GPU memory pool to grow up to
available device memory as needed for ordinary (non-collective) buffers
(XLA's
0.75+policy). SetXLA_CLIENT_MEM_FRACTION=0.75to keep theprevious fixed limit. Explicit XLA memory-policy flags take precedence, and
allocator modes that do not support growth retain their existing behavior
({jax-issue}
#41831).jax.shard_mapeagerly (outside
jax.jitor underjax.disable_jit()), avoiding repeatedrecompilation ({jax-issue}
#42470).jax.sharding.NamedSharding.shard_shapenow supports meshes withmanual axes.
jax.nn.softmax(and{func}
jax.scipy.special.softmax) by default(
jax_softmax_custom_jvp=True), improving memory use and numericalstability during differentiation. Set
jax.config.update("jax_softmax_custom_jvp", False)to temporarily restorethe previous behavior.
jax.lax.logand {func}jax.lax.log1pnow use vectorizedkernels on x86-64 (AVX2/AVX-512) and ARM64 (NEON), speeding up
float64by1.7×–4.4× and
float32by 19%–37%. This improvesfloat32accuracy forlog1p,log10,logit,acosh,asinh, andatanh, and relaxesfloat64CPUlogmax error from 0.5 to 1.5 units in the last place(ULPs), matching GPU; CPU tests expecting bit-exact
float64logmay see~1 ULP shifts.
accumulatefor {func}jax.numpy.bitwise_and,{func}
jax.numpy.bitwise_or, {func}jax.numpy.bitwise_xor,{func}
jax.numpy.logical_and, {func}jax.numpy.logical_or,{func}
jax.numpy.logical_xor, {func}jax.numpy.maximum, and{func}
jax.numpy.minimumnow uses a parallel prefix scan for integer andboolean outputs, which is much faster for long axes ({jax-issue}
#28097).jax.scipy.fft.dctand {func}jax.scipy.fft.idct({func}
jax.scipy.fft.idctn) now use real FFTs (rfft/irfft) insteadof full complex FFTs, speeding up batched
idctby up to 2.7× on GPU and9.4× on CPU ({jax-issue}
#42467, {jax-issue}#42583).jax.numpy.logaddexpand{func}
jax.numpy.logaddexp2using {func}jax.lax.logistic, makinggradient evaluation ~2–3× faster on CPU. Note that the gradient at
(inf, inf)now returnsnaninstead of1.0({jax-issue}#41914).jax.lax.lgamma({func}
jax.scipy.special.gammaln) and {func}jax.lax.digamma({func}
jax.scipy.special.digamma) with dedicated vectorized CPU kernels(using
highway, added as aMODULE.bazeldependency) and GPU kernels(CUDA/ROCm), improving compile time and speed while keeping error within
0.5 ULP (
bfloat16) and 1.0 ULP (float16,float32,float64) acrossCPU, GPU, and TPU. Also preserves very small (subnormal) inputs on GPU
instead of returning
±inf.jax.numpy.add, {func}jax.numpy.subtract,{func}
jax.numpy.multiply, and {func}jax.numpy.true_divide(
complex / real) no longer convert the real input to complex beforeoperating. This avoids unnecessary operations on zeros and fixes edge cases
with infinities and signed zeros (for example,
0.5 * (inf + 1j)nowreturns
inf + 0.5jinstead ofinf + nan*j).jax.lax.erfc(and{func}
jax.scipy.special.erfc) (jax_accurate_default_erfc=True). It usesfewer operations, preserves very small (subnormal) outputs on CPU and GPU,
returns
1.0at±0.0, and reduces worst-case rounding error (float32:from ~66 down to ≤7.0 ULPs on CPU, ≤7.5 on GPU, ≤9.5 on TPU v6e/7x, and
≤69.0 on TPU v2–v5p;
float64: from ≥350 down to ≤10.0 on CPU and GPU).With
accuracy=jax.lax.AccuracyMode.HIGHEST, worst-case error drops to≤1.5–2.0 ULPs with fewer operations, and
bfloat16drops from 63 to 25 opswith identical results. Set
jax_accurate_default_erfc=Falseto temporarilyrestore the previous behavior.
jax.lax.erf_invbydefault (
jax_accurate_erf_inv=True), fixing large precision loss near|x| = 1(float32: ~65 down to ≤2.0 ULPs on CPU, ≤2.5 on GPU/TPU v6e/7x,and ≤5.5 on TPU v5p;
float64: ~500,000 down to ≤2.5 ULPs on CPU and GPU).Also improved first- and higher-order derivative accuracy near
|x| = 1.Callers such as {func}
jax.scipy.special.erfinv,{func}
jax.scipy.special.ndtri, and default normal random samplers may seesmall last-bit numerical changes; set
jax_accurate_erf_inv=Falsetotemporarily restore the previous behavior.
jax.lax.exp2/ {func}jax.numpy.exp2and {func}jax.lax.log2/{func}
jax.numpy.log2now lower directly to native operations and supportaccuracy=jax.lax.AccuracyMode.HIGHEST, greatly reducing rounding erroracross dtypes and backends (for example,
exp2float32CPU: 68.5 → 0.5ULP, GPU: 69.0 → 2.5 ULP;
float64CPU: 719.0 → 0.5 ULP, GPU: 719.0 → 1.0ULP).
jax.scipy.special.gammaand {func}jax.scipy.special.factorial:≤0.5 ULP (
bfloat16) and ≤1.0 ULP (float16/float32/float64) acrossCPU, GPU, and TPU; exact
factorialup to34!(float32) and170!(
float64); preserves subnormal inputs on GPU.jax.lax.sinhand {func}jax.lax.cosh: vectorized CPU/TPUimplementations cut
float32error to ≤1.0 ULP (down from 25 ULPs on CPUand up to ~1794 ULPs on TPU) and
float64CPU error from 496 to ≤2.0ULPs, and fix premature
sinhoverflow near±89.4.jax.lax.asinand {func}jax.lax.acos: improved CPU and TPUfloat32error to ≤1.0 ULP and stopped flushing tiny normal inputs tozero in
asinon TPU.jax.lax.rsqrt: tightenedfloat32CPU error to ≤1.0 ULP on AVXx86-64 CPUs (≤1.5 ULP on ARM) by always running two refinement steps on
both Intel and AMD CPUs.
jax.lax.bessel_i0eand {func}jax.lax.bessel_i1e: fasterimplementation (~32 vs 85 ops in
float32) cuttingfloat32error from8.0 / 15.5 down to ≤2.0–3.0 ULPs and
float64from 7.5–10.5 down to ≤2.0ULPs.
jax.scipy.special.logit: fixed severe precision loss near0.5and
1(≤2.0–3.0 ULPs infloat32, ≤1.5 ULPs infloat64on CPU/GPU).jax.scipy.special.betalnand {func}jax.scipy.stats.t.logpdf:rewritten
betalnimproves accuracy for extreme ratios and negative ortiny inputs (raising
ValueErrorfor complex inputs), andt.logpdfavoids catastrophic cancellation for large degrees of freedom and in
float32on TPU ({jax-issue}#38243, {jax-issue}#39106,{jax-issue}
#41203).jax.scipy.special.ndtrand {func}jax.scipy.special.log_ndtr:fixed large negative-tail error, positive-input precision loss, premature
overflow, and derivative
NaNs, with accurate higher-order derivatives({jax-issue}
#41676).jax.lax.logistic({func}jax.nn.sigmoid,{func}
jax.scipy.special.expit): avoids overflow for large negativeinputs on GPU and in
float16across all backends, preserving very small(subnormal) outputs instead of flushing prematurely to
0.0.C++17). Linux wheels are built with LLVM 22, statically linked
libc++,and a
glibc 2.27(manylinux_2_27) sysroot. Hermetic CUDA 13 buildsupgraded from CUDA
13.0.0to13.4.1, and CUDA 12 source builds nowcompile device code with Clang.
libtpudependency forjax[tpu]from0.0.50.*to0.0.53.*({jax-issue}#42544).jaxlibagainst 64-bit integer BLAS/LAPACKlibraries (
-DJAX_LAPACK_ILP64), and fixed{func}
jax.scipy.linalg.lu_solvewhen SciPy uses 64-bit integer LAPACKwith
jax_enable_x64=True.manylinux_2_31(glibc 2.31), allowing installation on older Linuxdistributions ({jax-issue}
#42568).Bug fixes
jax.jitinstances of the same function that differonly in
static_argnums,static_argnames, orkeep_unusedsharinginternal dispatch cache entries, which could run the executable compiled
for one instance with the arguments of another and return wrong results
({jax-issue}
#42313).jax_high_dynamic_range_gumbelto thejax.jitcache key({jax-issue}
#40609).jax.lax.while_loop)and conditionals ({func}
jax.lax.cond) overlapping with later collectives,which could swap messages across processes or crash.
(LAPACK) calls run concurrently.
SIGSEGV) during complex GPU eigendecomposition({func}
jax.lax.linalg.eig/ {func}jax.numpy.linalg.eig) when usingMAGMA due to insufficient host buffer alignment.
std::bad_function_call) injaxlibwhen transferringduplicate host shards with forced copying enabled (for example,
jax.device_put(..., may_alias=False)).interface (FFI) targets via {func}
jax.ffi.register_ffi_target(where therecordcallback pointer was left uninitialized), and added support forthe
"record"handler stage.jax.pure_callback,{func}
jax.experimental.io_callback, andjax.experimental.buffer_callback) flushing very small (subnormal)floating-point values to zero.
jaxlib:despite sufficient free memory, by falling back to 1 GiB physical chunks
mapped into one contiguous virtual address range
(openxla/xla#52820).
broadcasted constant right-hand operand and a reduction
({jax-issue}
#41414, {jax-issue}#42549).multiplication with a constant left-hand operand and a reduction
({jax-issue}
#42651).sm_90+, CUDA 13.4+) forlarge-stride
float64column scatter overwrites ({jax-issue}#41888)..at[:].set(...)) immediatelyfollowed by reversing the array (
[::-1]) ({jax-issue}#41497).lax.log(lax.pow(a, b))returning finite values instead ofNaNfornegative bases under
jax.jit({jax-issue}#41261).forces a copy, and marks multi-device arrays as deleted when donating a
non-first shard ({jax-issue}
#41256).jax.lax.pmeanand constant {func}jax.lax.psumdividing ormultiplying every group by the first group's size when
axis_index_groupshas uneven group sizes ({jax-issue}
#41132).{func}
jax.lax.ragged_all_to_all({jax-issue}#41697).jax.lax.while_loopseeing stale values or dropping finalwrites when
cond_funreads or writes a mutableRef({jax-issue}
#41073).jax.lax.polynomialerrors inside {func}jax.shard_mapwithmixed constant and varying inputs ({jax-issue}
#41853).mixing unreduced or reduced arrays (under explicit sharding or
shard_map)with replicated constants in
pad,concatenate/stack, andselect_n.out_shardingbeing silently ignored when array indexing lowers tostatic or dynamic slicing.
full_like/empty_likein partially manual {func}jax.shard_map,mesh context mismatches when differentiating
jax.jitwithexplicit_axes,and false-positive
ForbiddenCollectiveErrorinjax.sharding.no_collectiveson 3-operandeinsum.jax.ref.new_ref(..., pin=True)errors when reading/writing pinnedreferences ({jax-issue}
#41846) or pinning buffers to TPU VMEM({jax-issue}
#41843).philox2x32/philox4x32(lax.mulhi) forward-compatibilityexport and compatibility with older
jaxlibbuilds.jax.exportdroppingweak_typeon outputs acrossserializeanddeserialize(bumping serialization format from 12 to 13,backward-compatible with older payloads) ({jax-issue}
#41007), bakingcaller stack traces into exported MLIR modules (causing non-deterministic
exports and cache misses), and lowering
jax.lax.platform_dependentbranches for incompatible platforms during multi-platform export.
Refaccumulator forwarding injax.custom_vjp.defvjp_with_accumsandjax.custom_gradient(with_accums=...)throughcheckpoint,jit,scan,and
checkify; also fixedrematwith tupleprevent_cseand closed-overconstants, improved leaked-tracer error messages, and avoided copying in
{func}
jax.numpy.moveaxiswhen no axes move ({jax-issue}#41717).jax.vmapof {func}jax.numpy.stackemitting an unnecessarytranspose when stacking along the batched axis ({jax-issue}
#41794).uint64oruint32values) wrapping around modulo2**32instead of clamping whencast to signed
int32during indexing ({jax-issue}#42657).dtypes (such as
int8(-1)) on long axes across indexing, dynamic slicing,{func}
jax.numpy.take, and {func}jax.numpy.put; also madejax.dsslices consistent between eager and
jitexecution ({jax-issue}#42354,{jax-issue}
#42377).jax.numpy.interpreturningnanat and around sample pointswhose
fpvalue is infinite; it now returns the sample value or the signedinfinity, matching NumPy. For complex
fp, the real and imaginary partsare now interpolated separately, as in NumPy ({jax-issue}
#42318). Alsofixed
interpmishandling narrow intervals, duplicate trailingxpcoordinates,
NaNquery inputs, andNaNderivatives at narrow orduplicate boundaries ({jax-issue}
#42650).jax.numpy.modfreturningnanas the fractional part forinfinite inputs; it now returns a signed zero, matching NumPy
({jax-issue}
#41102).jax.numpy.nonzero, {func}jax.numpy.flatnonzero, and{func}
jax.numpy.argwhereignoringfill_valueon empty arrays({jax-issue}
#42233).jax.numpy.nan_to_numoverwriting custom replacement values asecond time when replacing
NaNwith infinity ({jax-issue}#42406).jax.numpy.gcdand {func}jax.numpy.lcmforminimum representable signed integers such as
int32(-2**31)({jax-issue}
#40840).jax.numpy.choosewrapping indices when the number of choicesexceeds a narrow index dtype's maximum ({jax-issue}
#42464).jax.numpy.kronand {func}jax.numpy.vanderfailing onboolean inputs ({jax-issue}
#42462).jax.numpy.quantile, {func}jax.numpy.nanquantile,{func}
jax.numpy.percentile, and {func}jax.numpy.nanpercentile(withmethod="inverted_cdf") returning zero-weight elements atq=0({jax-issue}
#42190).jax.scipy.linalg.polarwithmethod="qdwh"now honorsmax_iterationsand acceptseps, as documented; previouslymax_iterationswas silently ignored and any non-Noneepsraised aValueError. Bothepsandmax_iterationsare now static arguments ofpolar(for allmethodvalues), so passing a traced value for eitherraises an error ({jax-issue}
#41917).jvp) of pivoted QR decomposition({func}
jax.lax.linalg.qr, {func}jax.scipy.linalg.qr) for wide matrices(
m < n) ({jax-issue}#42634).jax.scipy.linalg.toeplitzand {func}jax.scipy.linalg.hankelspreading a single
NaNorinfacross the entire output matrix({jax-issue}
#38635, {jax-issue}#38636).jax.scipy.sparse.linalg.cgproducingNaNs or stopping earlywhen the right-hand side or initial guess has very small or very large
magnitude (for example, during differentiation with a preconditioner)
({jax-issue}
#40254).jax.scipy.signal.convolve,convolve2d,correlate, andcorrelate2draisingValueErroron mixed-size multidimensional arraysfor
mode="full"andmode="same", matching SciPy ({jax-issue}#42063).{func}
jax.experimental.sparse.coo_fromdenseand{func}
jax.experimental.sparse.csr_fromdense(COO/CSR/CSC.fromdense)when
nse > nnz({jax-issue}#40624).jax.experimental.sparse.bcoo_reshape(BCOO.reshape)miscomputing shapes for sparse arrays with dense dimensions
({jax-issue}
#24795).x / y,{func}
jax.lax.div) for very large or very small denominators({jax-issue}
#37909).NaNgradients at single-axis infinities for complex {func}
jax.numpy.abs,{func}
jax.numpy.hypot, and {func}jax.numpy.arctan2({func}
jax.lax.atan2) ({jax-issue}#25681).jax.nn.soft_signreturningNaNat±inf(now returns±1)and losing derivative accuracy for large inputs.
jax.nn.softmaxwithwhereleakingNaNinto gradients whenmasked-out positions have
NaNor infinite tangents/cotangents.jax.nn.log1mexp.jax.nn.squareplusfor largeinputs in
float16({jax-issue}#41647).{func}
jax.nn.get_scaled_dot_general_configfor'nvfp4'({jax-issue}
#42025).jax.scipy.special.fresnelat odd integers and
0.jax.scipy.special.i0({func}
jax.numpy.i0) and {func}jax.scipy.special.i1for large finiteinputs ({jax-issue}
#39770, {jax-issue}#39772).jax.scipy.special.expireturningNaNinstead ofinfat+inf({jax-issue}#38519).jax.scipy.special.loggammareturningNaNinstead ofinfat0.0and-0.0({jax-issue}#38240).jax.scipy.special.zetaand{func}
jax.scipy.special.polygammafor large or infiniteq({jax-issue}
#41366).NaNgradients in {mod}jax.scipy.stats.paretomethods outside thedistribution's domain ({jax-issue}
#41445).float32precision loss in {func}jax.scipy.stats.nbinom.logpmf({jax-issue}
#42145).logpmfandpmffor discrete distributions injax.scipy.stats(
betabinom,bernoulli,binom,geom, andnbinom) to return-inf(
0forpmf) for non-integerk - loc, matching SciPy; also fixedlocbound checks in
betabinom({jax-issue}#41745, {jax-issue}#41960).jax.random.poissonreturning undefined values or raisingunder
jax.debug_nans(True)whenlamis infinite or non-finite({jax-issue}
#38335).jax.random.multivariate_normalwithmethod="eigh"returningNaNon singular or near-singular covariance matrices ({jax-issue}#14345).jax.random.choicedropping other array dimensions whendrawing zero samples ({jax-issue}
#42429).jax.debug.breakpointwithbackend="web"crashing underweb-pdb2.x.op_name) metadata in compiled HLO whenjax_include_full_tracebacks_in_locations=False({jax-issue}#41587).jax_explain_cache_misses=Truewhendebug_infoispassed as a keyword argument ({jax-issue}
#41455) or argument names areunknown.
v0.12.0.1Compare Source
clang-clinstead ofemitting empty bitcode, enabling vectorized CPU intrinsics on Windows
(openxla/xla@
3af77b5).v0.12.0Compare Source
clang-clinstead ofemitting empty bitcode, enabling vectorized CPU intrinsics on Windows
(openxla/xla@
3af77b5).v0.11.2Compare Source
New features
jax.numpy.minmax(andjnp.minmax), which returns both theminimum and maximum of an array, matching NumPy 2.3+ ({jax-issue}
#40089).jax.lax.log2and primitive {data}jax.lax.log2_p, makinglog2a first-class primitive in JAX ({func}jax.numpy.log2now lowers viajax.lax.log2).jax.lax.one_minus_squareprimitive to accurately compute1 - x^2nearjax.export.symbolic_dim_boundsfor querying conservativebounds on symbolic dimension expressions ({jax-issue}
#40006).frozendictsupport to JAX pytrees for Python 3.15 (PEP 814).jax.distributed.initializecan now secure the coordination servicewith mutual TLS via the new
mtls_cert_file,mtls_key_file,mtls_ca_file,mtls_peer_uri_prefixandverify_secure_credentialsarguments (or the
JAX_MTLS_CERT_FILE,JAX_MTLS_KEY_FILE,JAX_MTLS_CA_FILE,JAX_MTLS_PEER_URI_PREFIXandJAX_DISTRIBUTED_VERIFY_SECURE_CREDENTIALSenvironment variables).{func}
jax.distributed.initialize({jax-issue}#40512).TPU_PROCESS_ADDRESSES_PATHin GKE TPU clusters.jax.random.generalized_normal'spparameter type fromfloattoRealArray, allowing array-valued shape parameters ({jax-issue}#40126).exclude_argnamesargument to {func}jax.experimental.program_order.(
geqrf,orgqr/ungqr,ormqr/unmqr), LU decomposition (getrf),symmetric/Hermitian eigenvalue decomposition (
syevd/heevd), SVD(
gesvd), and hybrid solver kernels (geqp3,eig)({jax-issue}
#40000, {jax-issue}#40186, {jax-issue}#40543).jaxlibwheels now ship C++ FFI extension headers (collectives.h,record.h) to support out-of-tree plugins ({jax-issue}#40333).Breaking changes
jax.experimental.shard_alike. Use explicit shardingmode instead (see {ref}
jax-201-sharding).Changes
jax.sharding.Meshconstruction by avoidingredundant device array allocations and copies.
jaxlibfor free-threaded Python(Python 3.13t, 3.14t, 3.15t).
inline=Truein {func}jax.jitnow corresponds to{attr}
jax.Inline.JAX_LATEinstead of {attr}jax.Inline.JAX_EARLY.jax.numpy.fft.irfftn,{func}
jax.numpy.fft.irfft2and {func}jax.lax.fftwithFftType.IRFFT)are again lowered to a single C2R transform, as before JAX 0.10.0, instead
of an IFFT over the outer axes and a 1-D IRFFT with two transposes. The
input is first made Hermitian-symmetric along the outer axes, which does
not change the result under NumPy's convention (only the last axis is
assumed symmetric), so results are unchanged while the transform is
~1.4x faster at typical sizes.
jax.numpy.cumsum)on GPU, improving performance.
jax.numpy.trinow returns an array with the default float dtypewhen the
dtypeargument is not specified. Previously it always returnedfloat32({jax-issue}#40242).jax.numpy.uniquewithaxisspecified now matches NumPy's outputshape for arrays that are empty along the given axis, instead of
fabricating a phantom slice for fully-empty inputs.
jax.numpy.log2by pre-computing the1 / log(2)constant factor ({jax-issue}#40430).out_shardingparameter to {func}jax.numpy.histogram.jax.remat'sprevent_cseargument signature to acceptbool | Sequence[bool], matching {func}jax.checkpoint.jax.experimental.checkifyerror code assignment deterministic.Bug fixes
jax.numpy.arccoshand {func}jax.lax.acoshgradients for large inputs ({jax-issue}
#40643, {jax-issue}#40634).{func}
jax.lax.bessel_i0eand {func}jax.lax.bessel_i1eat0.0({jax-issue}
#40640, {jax-issue}#40635).jax.numpy.linalg.eighgradients producing NaN or incorrectvalues for large eigenvalues ({jax-issue}
#40149, {jax-issue}#40141).jax.numpy.sincnow uses a Taylor series near zero, givingaccurate derivatives of all orders. Previously, autodiff of the
sin(πx)/(πx)quotient suffered catastrophic cancellation near zero({jax-issue}
#34139, {jax-issue}#10750).jax.numpy.partition, {func}jax.numpy.argpartitionand{func}
jax.numpy.top_kwithmode='smallest'on signed integer arrayscontaining the smallest representable value, which was treated as the
largest element and dropped from the result.
jax.numpy.partitionand {func}jax.numpy.argpartitionnow acceptboolean arrays, as {func}
jax.numpy.top_kalready did.jax.numpy.linalg.condreturned NaN instead ofinfinity for singular matrices when
pisNoneor2, matching NumPyand the other norms.
jax.numpy.histogramcrashing on empty arrays({jax-issue}
#40025, {jax-issue}#40020).jax.numpy.intersect1dand {func}jax.numpy.setxor1dwithsize=0, which previously raised a ValueError; they now return emptyarrays of the natural result dtype.
jax.numpy.setdiff1draising anIndexErrorwhen called withsize=0on non-empty inputs; it now returns an empty array.jax.scipy.linalg.choleskyand{func}
jax.numpy.linalg.choleskywithsymmetrize_input=Falsewherenon-zero gradients leaked into the unused triangle of the input matrix
({jax-issue}
#40421).jax.numpy.medianon an input that is empty along thereduction axis, which previously raised an internal error from
gather;it now raises a
ValueError.{func}
jax.nn.initializers.variance_scalingfor zero-size inputs({jax-issue}
#35096).jax.custom_roottangents when auxiliary values areinteger-typed ({jax-issue}
#39913, {jax-issue}#24295).jax.debug.visualize_array_sharding({jax-issue}
#39922, {jax-issue}#25695).jax.lax.minand {func}jax.lax.maxto notdepend on bitwise equivalence between forward and backward pass results
({jax-issue}
#40578).jax.exportwheneven-powered factor bounds cross zero or zero factors are paired with
infinite bounds ({jax-issue}
#40054).ref_addupdate) on indexedReshapeTransformviews.FFTs ({jax-issue}
#40389).jax.vmapof a {func}jax.lax.scanwhose body closes overor scans over a Ref batched along a non-leading axis, which previously
failed with
AttributeError: 'Ref' object has no attribute 'transpose'({jax-issue}
#39288).v0.11.1Compare Source
New features
than the backwards compatibility window. Without this check the
deserialization of expired artifacts may succeed and then result in
obscure downstream errors.
Added a configuration flag
--jax_export_deserialize_expired_versionstotemporarily bypass the error check.
See https://docs.jax.dev/en/latest/export/export.html#compatibility-guarantees.
jax.numpy.top_k, which implements {func}numpy.top_k, added inin NumPy v2.6.0 ({jax-issue}
#39729).Breaking changes
exec_time_optimization_effortandmemory_fitting_effortflags have beenremoved in favor of the
EffortLevelenum.before January 15th, 2026 because they are beyond the backwards compatibility
window. On that date we added support to serialize shardings as NamedSharding,
and now that is the only sharding serialization that is supported.
It used to default to False for mode=promise_in_bounds and True otherwise.
(This also means None is no longer a valid value for wrap_negative_indices.)
Deprecations
in_shardings_hloandout_shardings_hloofjax.export.Exportedhave been deprecated for a while. Now accessing themraises a warning. Use
in_shardings_jaxandout_shardings_jaxinstead.Changes
{func}
jax.nn.dot_product_attentionwithimplementation='cudnn') nolonger computes a bias gradient when the only attention bias comes from
a boolean
mask, whose gradient no caller can request. Bias gradientsfor an explicit
biasor a non-booleanmaskare unchanged({jax-issue}
#34685).jax.numpy.meshgrid, {obj}jax.numpy.ogrid, and{func}
jax.numpy.broadcast_arraysnow return tuples rather than listsin order to align with NumPy>2.0 and the Array API specification.
({jax-issue}
#39783, {jax-issue}#39789, {jax-issue}#39802)jax.grador {func}jax.value_and_gradrejects a function witha non-scalar output, the error message now suggests reducing the output
to a scalar (e.g. with
output.sum()), using {func}jax.jacobian, orreshaping size-1 outputs ({jax-issue}
#2303).now suggests using {func}
jax.lax.dynamic_slice,{func}
jax.lax.dynamic_update_slice, orjax.ds, and shows tracerprovenance ({jax-issue}
#7222).registered pytree type that caused the error ({jax-issue}
#13027).Bug fixes
jax.numpy.linalg.detand {func}jax.numpy.linalg.slogdetnow use aclosed-form LU decomposition with row pivoting for 2x2 and 3x3 matrices
instead of closed-form polynomial expansions to avoid numerical instability
and catastrophic cancellation ({jax-issue}
#39905).jax_explain_cache_missesis enabled and ajax.custom_batching.custom_vmap-decorated function (orcustom_partitioning,custom_gradient,closure_convert,linear_call, orrun_state) is retraced with different-shapedarguments ({jax-issue}
#40110).{func}
jax.nn.dot_product_attentionwithimplementation='cudnn') nowsupport operands that do not carry the vmap axis, including a shared
bias or
mask. Previouslyjax.jacobian,jax.vmapwith partialin_axes, andjax.vmapof a VJP or ofjax.gradfailed with areshape
TypeError({jax-issue}#38495).jax.vmapof fp8 cuDNN fused attention now works: its batching rulesadditionally mislabeled or dropped the amax outputs and restored output
shapes incorrectly, so previously no vmap of the fp8 path succeeded at
all. The amax outputs are whole-batch statistics and do not carry the
vmap axis; vmap over the scale/descale operands raises a clear
NotImplementedError.jax_compiler_enable_remat_passtoFalsenow addsrematerializationto the set of disabled XLA passes instead ofoverwriting it, so HLO passes disabled via
XLA_FLAGS=--xla_disable_hlo_passes=...stay disabled({jax-issue}
#37391).jax.numpy.split, {func}jax.numpy.array_split, and thehsplit/vsplit/dsplitvariants once again accept negative entries inindices_or_sections, resolving them against the axis size as NumPy does({jax-issue}
#6599). Out-of-bound indices are now clipped to the axisbounds and produce empty sections, also matching NumPy, instead of raising
ValueError: Sizes passed to split must be nonnegative.jax.lax.scanto only check.matequivalency when the abstract value is a
ShapedArray({jax-issue}
#39700).jax.lax.reshapewhen reshaping arrays with sharding constraints ({jax-issue}
#39309).jax.tree_util.flatten_one_level_with_keysfornamedtupleinstances ({jax-issue}
#39297)._get_prime_factorsinjax.experimental.mesh_utils({jax-issue}
#38286).PyTreeDef.deserialize_using_protonow raisesValueErrorfor amalformed
PyTreeDefProtoinstead of crashing the interpreter. A nodewhose arity exceeds the subtrees preceding it is rejected, as is a dict
node whose arity disagrees with its key list, which previously segfaulted
later, when the structure was used to unflatten.
PyTreeDef.composelikewise raisesValueErrorrather than crashing whenan operand carries such an inconsistent arity, which is reachable from
pickle.loads({jax-issue}#37410).v0.11.0Compare Source
New features
hijax API ({ref}
hijax-custom-derivatives), along withjax.experimental.hijaxhelpers for derivingHiPrimautodiffrules from a
jvporlinrule:linearize_from_jvpwithapply_derived_linearization,vjp_fwd_from_jvpwithtranspose_jvp,vjp_fwd_from_linwithtranspose_linearized, andjvp_from_lin.jax.custom_rematto the top-leveljaxnamespace, forper-function control of rematerialization under the new
jax_remat3implementation.
jax.checkpoint_policiesis now a submodule rather than a namespaceobject (so
from jax.checkpoint_policies import ...now works; attributeaccess is unchanged).
jax.Inlineenum for specify inlining policies to{func}
jax.jit.Breaking changes
references to it can be safely removed.
deprecation policy.
Configuration
📅 Schedule: (UTC)
🚦 Automerge: Enabled.
♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.
🔕 Ignore: Close this PR and you won't be reminded about this update again.
This PR was generated by Mend Renovate. View the repository job log.